de.caff.generics.tuple

## Interface ITuple5<T1,T2,T3,T4,T5>

- 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
  All Known Implementing Classes:
    ITuple5.Base, NTuple5, Tuple5

      public interface ITuple5<T1,T2,T3,T4,T5>

  General interface for immutable 5-tuples.

  This is sometimes useful to access either `Tuple5` or `NTuple5` 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(ITuple5)` 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:
    `Tuple5`, `NTuple5`

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Interface and Description
    --- | ---
    `static class` | `ITuple5.Base<T1,T2,T3,T4,T5>` Abstract base implementation of a 5-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 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,T4>` | `_12354()` Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 5th, 4th.
    `default ITuple3<T1,T2,T4>` | `_124()` Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 4th.
    `default ITuple5<T1,T2,T4,T3,T5>` | `_12435()` Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 3rd, 5th.
    `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,T3>` | `_12453()` Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 5th, 3rd.
    `default ITuple3<T1,T2,T5>` | `_125()` Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 5th.
    `default ITuple5<T1,T2,T5,T3,T4>` | `_12534()` Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 5th, 3rd, 4th.
    `default ITuple5<T1,T2,T5,T4,T3>` | `_12543()` Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 5th, 4th, 3rd.
    `default ITuple2<T1,T3>` | `_13()` Create a new 2-tuple from this one where the elements are ordered: 1st, 3rd.
    `default ITuple3<T1,T3,T2>` | `_132()` Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 2nd.
    `default ITuple5<T1,T3,T2,T4,T5>` | `_13245()` Create a new 5-tuple from this one where the elements are ordered: 1st, 3rd, 2nd, 4th, 5th.
    `default ITuple5<T1,T3,T2,T5,T4>` | `_13254()` Create a new 5-tuple from this one where the elements are ordered: 1st, 3rd, 2nd, 5th, 4th.
    `default ITuple3<T1,T3,T4>` | `_134()` Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 4th.
    `default ITuple5<T1,T3,T4,T2,T5>` | `_13425()` Create a new 5-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 2nd, 5th.
    `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,T2>` | `_13452()` Create a new 5-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 5th, 2nd.
    `default ITuple3<T1,T3,T5>` | `_135()` Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 5th.
    `default ITuple5<T1,T3,T5,T2,T4>` | `_13524()` Create a new 5-tuple from this one where the elements are ordered: 1st, 3rd, 5th, 2nd, 4th.
    `default ITuple5<T1,T3,T5,T4,T2>` | `_13542()` Create a new 5-tuple from this one where the elements are ordered: 1st, 3rd, 5th, 4th, 2nd.
    `default ITuple2<T1,T4>` | `_14()` Create a new 2-tuple from this one where the elements are ordered: 1st, 4th.
    `default ITuple3<T1,T4,T2>` | `_142()` Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 2nd.
    `default ITuple5<T1,T4,T2,T3,T5>` | `_14235()` Create a new 5-tuple from this one where the elements are ordered: 1st, 4th, 2nd, 3rd, 5th.
    `default ITuple5<T1,T4,T2,T5,T3>` | `_14253()` Create a new 5-tuple from this one where the elements are ordered: 1st, 4th, 2nd, 5th, 3rd.
    `default ITuple3<T1,T4,T3>` | `_143()` Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 3rd.
    `default ITuple5<T1,T4,T3,T2,T5>` | `_14325()` Create a new 5-tuple from this one where the elements are ordered: 1st, 4th, 3rd, 2nd, 5th.
    `default ITuple5<T1,T4,T3,T5,T2>` | `_14352()` Create a new 5-tuple from this one where the elements are ordered: 1st, 4th, 3rd, 5th, 2nd.
    `default ITuple3<T1,T4,T5>` | `_145()` Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 5th.
    `default ITuple5<T1,T4,T5,T2,T3>` | `_14523()` Create a new 5-tuple from this one where the elements are ordered: 1st, 4th, 5th, 2nd, 3rd.
    `default ITuple5<T1,T4,T5,T3,T2>` | `_14532()` Create a new 5-tuple from this one where the elements are ordered: 1st, 4th, 5th, 3rd, 2nd.
    `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 ITuple5<T1,T5,T2,T3,T4>` | `_15234()` Create a new 5-tuple from this one where the elements are ordered: 1st, 5th, 2nd, 3rd, 4th.
    `default ITuple5<T1,T5,T2,T4,T3>` | `_15243()` Create a new 5-tuple from this one where the elements are ordered: 1st, 5th, 2nd, 4th, 3rd.
    `default ITuple3<T1,T5,T3>` | `_153()` Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 3rd.
    `default ITuple5<T1,T5,T3,T2,T4>` | `_15324()` Create a new 5-tuple from this one where the elements are ordered: 1st, 5th, 3rd, 2nd, 4th.
    `default ITuple5<T1,T5,T3,T4,T2>` | `_15342()` Create a new 5-tuple from this one where the elements are ordered: 1st, 5th, 3rd, 4th, 2nd.
    `default ITuple3<T1,T5,T4>` | `_154()` Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 4th.
    `default ITuple5<T1,T5,T4,T2,T3>` | `_15423()` Create a new 5-tuple from this one where the elements are ordered: 1st, 5th, 4th, 2nd, 3rd.
    `default ITuple5<T1,T5,T4,T3,T2>` | `_15432()` Create a new 5-tuple from this one where the elements are ordered: 1st, 5th, 4th, 3rd, 2nd.
    `T2` | `_2()` Get the second element.
    `default ITuple2<T2,T1>` | `_21()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 1st.
    `default ITuple3<T2,T1,T3>` | `_213()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 3rd.
    `default ITuple5<T2,T1,T3,T4,T5>` | `_21345()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 1st, 3rd, 4th, 5th.
    `default ITuple5<T2,T1,T3,T5,T4>` | `_21354()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 1st, 3rd, 5th, 4th.
    `default ITuple3<T2,T1,T4>` | `_214()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 4th.
    `default ITuple5<T2,T1,T4,T3,T5>` | `_21435()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 1st, 4th, 3rd, 5th.
    `default ITuple5<T2,T1,T4,T5,T3>` | `_21453()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 1st, 4th, 5th, 3rd.
    `default ITuple3<T2,T1,T5>` | `_215()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 5th.
    `default ITuple5<T2,T1,T5,T3,T4>` | `_21534()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 1st, 5th, 3rd, 4th.
    `default ITuple5<T2,T1,T5,T4,T3>` | `_21543()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 1st, 5th, 4th, 3rd.
    `default ITuple2<T2,T3>` | `_23()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 3rd.
    `default ITuple3<T2,T3,T1>` | `_231()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 1st.
    `default ITuple5<T2,T3,T1,T4,T5>` | `_23145()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 3rd, 1st, 4th, 5th.
    `default ITuple5<T2,T3,T1,T5,T4>` | `_23154()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 3rd, 1st, 5th, 4th.
    `default ITuple3<T2,T3,T4>` | `_234()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 4th.
    `default ITuple5<T2,T3,T4,T1,T5>` | `_23415()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 1st, 5th.
    `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,T1>` | `_23451()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 5th, 1st.
    `default ITuple3<T2,T3,T5>` | `_235()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 5th.
    `default ITuple5<T2,T3,T5,T1,T4>` | `_23514()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 3rd, 5th, 1st, 4th.
    `default ITuple5<T2,T3,T5,T4,T1>` | `_23541()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 3rd, 5th, 4th, 1st.
    `default ITuple2<T2,T4>` | `_24()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 4th.
    `default ITuple3<T2,T4,T1>` | `_241()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 1st.
    `default ITuple5<T2,T4,T1,T3,T5>` | `_24135()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 4th, 1st, 3rd, 5th.
    `default ITuple5<T2,T4,T1,T5,T3>` | `_24153()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 4th, 1st, 5th, 3rd.
    `default ITuple3<T2,T4,T3>` | `_243()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 3rd.
    `default ITuple5<T2,T4,T3,T1,T5>` | `_24315()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 4th, 3rd, 1st, 5th.
    `default ITuple5<T2,T4,T3,T5,T1>` | `_24351()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 4th, 3rd, 5th, 1st.
    `default ITuple3<T2,T4,T5>` | `_245()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 5th.
    `default ITuple5<T2,T4,T5,T1,T3>` | `_24513()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 4th, 5th, 1st, 3rd.
    `default ITuple5<T2,T4,T5,T3,T1>` | `_24531()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 4th, 5th, 3rd, 1st.
    `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 ITuple5<T2,T5,T1,T3,T4>` | `_25134()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 5th, 1st, 3rd, 4th.
    `default ITuple5<T2,T5,T1,T4,T3>` | `_25143()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 5th, 1st, 4th, 3rd.
    `default ITuple3<T2,T5,T3>` | `_253()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 3rd.
    `default ITuple5<T2,T5,T3,T1,T4>` | `_25314()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 5th, 3rd, 1st, 4th.
    `default ITuple5<T2,T5,T3,T4,T1>` | `_25341()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 5th, 3rd, 4th, 1st.
    `default ITuple3<T2,T5,T4>` | `_254()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 4th.
    `default ITuple5<T2,T5,T4,T1,T3>` | `_25413()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 5th, 4th, 1st, 3rd.
    `default ITuple5<T2,T5,T4,T3,T1>` | `_25431()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 5th, 4th, 3rd, 1st.
    `T3` | `_3()` Get the third element.
    `default ITuple2<T3,T1>` | `_31()` Create a new 2-tuple from this one where the elements are ordered: 3rd, 1st.
    `default ITuple3<T3,T1,T2>` | `_312()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 2nd.
    `default ITuple5<T3,T1,T2,T4,T5>` | `_31245()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 1st, 2nd, 4th, 5th.
    `default ITuple5<T3,T1,T2,T5,T4>` | `_31254()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 1st, 2nd, 5th, 4th.
    `default ITuple3<T3,T1,T4>` | `_314()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 4th.
    `default ITuple5<T3,T1,T4,T2,T5>` | `_31425()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 1st, 4th, 2nd, 5th.
    `default ITuple5<T3,T1,T4,T5,T2>` | `_31452()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 1st, 4th, 5th, 2nd.
    `default ITuple3<T3,T1,T5>` | `_315()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 5th.
    `default ITuple5<T3,T1,T5,T2,T4>` | `_31524()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 1st, 5th, 2nd, 4th.
    `default ITuple5<T3,T1,T5,T4,T2>` | `_31542()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 1st, 5th, 4th, 2nd.
    `default ITuple2<T3,T2>` | `_32()` Create a new 2-tuple from this one where the elements are ordered: 3rd, 2nd.
    `default ITuple3<T3,T2,T1>` | `_321()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 1st.
    `default ITuple5<T3,T2,T1,T4,T5>` | `_32145()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 2nd, 1st, 4th, 5th.
    `default ITuple5<T3,T2,T1,T5,T4>` | `_32154()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 2nd, 1st, 5th, 4th.
    `default ITuple3<T3,T2,T4>` | `_324()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 4th.
    `default ITuple5<T3,T2,T4,T1,T5>` | `_32415()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 2nd, 4th, 1st, 5th.
    `default ITuple5<T3,T2,T4,T5,T1>` | `_32451()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 2nd, 4th, 5th, 1st.
    `default ITuple3<T3,T2,T5>` | `_325()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 5th.
    `default ITuple5<T3,T2,T5,T1,T4>` | `_32514()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 2nd, 5th, 1st, 4th.
    `default ITuple5<T3,T2,T5,T4,T1>` | `_32541()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 2nd, 5th, 4th, 1st.
    `default ITuple2<T3,T4>` | `_34()` Create a new 2-tuple from this one where the elements are ordered: 3rd, 4th.
    `default ITuple3<T3,T4,T1>` | `_341()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 1st.
    `default ITuple5<T3,T4,T1,T2,T5>` | `_34125()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 4th, 1st, 2nd, 5th.
    `default ITuple5<T3,T4,T1,T5,T2>` | `_34152()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 4th, 1st, 5th, 2nd.
    `default ITuple3<T3,T4,T2>` | `_342()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 2nd.
    `default ITuple5<T3,T4,T2,T1,T5>` | `_34215()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 4th, 2nd, 1st, 5th.
    `default ITuple5<T3,T4,T2,T5,T1>` | `_34251()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 4th, 2nd, 5th, 1st.
    `default ITuple3<T3,T4,T5>` | `_345()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 5th.
    `default ITuple5<T3,T4,T5,T1,T2>` | `_34512()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 4th, 5th, 1st, 2nd.
    `default ITuple5<T3,T4,T5,T2,T1>` | `_34521()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 4th, 5th, 2nd, 1st.
    `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 ITuple5<T3,T5,T1,T2,T4>` | `_35124()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 5th, 1st, 2nd, 4th.
    `default ITuple5<T3,T5,T1,T4,T2>` | `_35142()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 5th, 1st, 4th, 2nd.
    `default ITuple3<T3,T5,T2>` | `_352()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 2nd.
    `default ITuple5<T3,T5,T2,T1,T4>` | `_35214()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 5th, 2nd, 1st, 4th.
    `default ITuple5<T3,T5,T2,T4,T1>` | `_35241()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 5th, 2nd, 4th, 1st.
    `default ITuple3<T3,T5,T4>` | `_354()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 4th.
    `default ITuple5<T3,T5,T4,T1,T2>` | `_35412()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 5th, 4th, 1st, 2nd.
    `default ITuple5<T3,T5,T4,T2,T1>` | `_35421()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 5th, 4th, 2nd, 1st.
    `T4` | `_4()` Get the fourth element.
    `default ITuple2<T4,T1>` | `_41()` Create a new 2-tuple from this one where the elements are ordered: 4th, 1st.
    `default ITuple3<T4,T1,T2>` | `_412()` Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 2nd.
    `default ITuple5<T4,T1,T2,T3,T5>` | `_41235()` Create a new 5-tuple from this one where the elements are ordered: 4th, 1st, 2nd, 3rd, 5th.
    `default ITuple5<T4,T1,T2,T5,T3>` | `_41253()` Create a new 5-tuple from this one where the elements are ordered: 4th, 1st, 2nd, 5th, 3rd.
    `default ITuple3<T4,T1,T3>` | `_413()` Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 3rd.
    `default ITuple5<T4,T1,T3,T2,T5>` | `_41325()` Create a new 5-tuple from this one where the elements are ordered: 4th, 1st, 3rd, 2nd, 5th.
    `default ITuple5<T4,T1,T3,T5,T2>` | `_41352()` Create a new 5-tuple from this one where the elements are ordered: 4th, 1st, 3rd, 5th, 2nd.
    `default ITuple3<T4,T1,T5>` | `_415()` Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 5th.
    `default ITuple5<T4,T1,T5,T2,T3>` | `_41523()` Create a new 5-tuple from this one where the elements are ordered: 4th, 1st, 5th, 2nd, 3rd.
    `default ITuple5<T4,T1,T5,T3,T2>` | `_41532()` Create a new 5-tuple from this one where the elements are ordered: 4th, 1st, 5th, 3rd, 2nd.
    `default ITuple2<T4,T2>` | `_42()` Create a new 2-tuple from this one where the elements are ordered: 4th, 2nd.
    `default ITuple3<T4,T2,T1>` | `_421()` Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 1st.
    `default ITuple5<T4,T2,T1,T3,T5>` | `_42135()` Create a new 5-tuple from this one where the elements are ordered: 4th, 2nd, 1st, 3rd, 5th.
    `default ITuple5<T4,T2,T1,T5,T3>` | `_42153()` Create a new 5-tuple from this one where the elements are ordered: 4th, 2nd, 1st, 5th, 3rd.
    `default ITuple3<T4,T2,T3>` | `_423()` Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 3rd.
    `default ITuple5<T4,T2,T3,T1,T5>` | `_42315()` Create a new 5-tuple from this one where the elements are ordered: 4th, 2nd, 3rd, 1st, 5th.
    `default ITuple5<T4,T2,T3,T5,T1>` | `_42351()` Create a new 5-tuple from this one where the elements are ordered: 4th, 2nd, 3rd, 5th, 1st.
    `default ITuple3<T4,T2,T5>` | `_425()` Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 5th.
    `default ITuple5<T4,T2,T5,T1,T3>` | `_42513()` Create a new 5-tuple from this one where the elements are ordered: 4th, 2nd, 5th, 1st, 3rd.
    `default ITuple5<T4,T2,T5,T3,T1>` | `_42531()` Create a new 5-tuple from this one where the elements are ordered: 4th, 2nd, 5th, 3rd, 1st.
    `default ITuple2<T4,T3>` | `_43()` Create a new 2-tuple from this one where the elements are ordered: 4th, 3rd.
    `default ITuple3<T4,T3,T1>` | `_431()` Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 1st.
    `default ITuple5<T4,T3,T1,T2,T5>` | `_43125()` Create a new 5-tuple from this one where the elements are ordered: 4th, 3rd, 1st, 2nd, 5th.
    `default ITuple5<T4,T3,T1,T5,T2>` | `_43152()` Create a new 5-tuple from this one where the elements are ordered: 4th, 3rd, 1st, 5th, 2nd.
    `default ITuple3<T4,T3,T2>` | `_432()` Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 2nd.
    `default ITuple5<T4,T3,T2,T1,T5>` | `_43215()` Create a new 5-tuple from this one where the elements are ordered: 4th, 3rd, 2nd, 1st, 5th.
    `default ITuple5<T4,T3,T2,T5,T1>` | `_43251()` Create a new 5-tuple from this one where the elements are ordered: 4th, 3rd, 2nd, 5th, 1st.
    `default ITuple3<T4,T3,T5>` | `_435()` Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 5th.
    `default ITuple5<T4,T3,T5,T1,T2>` | `_43512()` Create a new 5-tuple from this one where the elements are ordered: 4th, 3rd, 5th, 1st, 2nd.
    `default ITuple5<T4,T3,T5,T2,T1>` | `_43521()` Create a new 5-tuple from this one where the elements are ordered: 4th, 3rd, 5th, 2nd, 1st.
    `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 ITuple5<T4,T5,T1,T2,T3>` | `_45123()` Create a new 5-tuple from this one where the elements are ordered: 4th, 5th, 1st, 2nd, 3rd.
    `default ITuple5<T4,T5,T1,T3,T2>` | `_45132()` Create a new 5-tuple from this one where the elements are ordered: 4th, 5th, 1st, 3rd, 2nd.
    `default ITuple3<T4,T5,T2>` | `_452()` Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 2nd.
    `default ITuple5<T4,T5,T2,T1,T3>` | `_45213()` Create a new 5-tuple from this one where the elements are ordered: 4th, 5th, 2nd, 1st, 3rd.
    `default ITuple5<T4,T5,T2,T3,T1>` | `_45231()` Create a new 5-tuple from this one where the elements are ordered: 4th, 5th, 2nd, 3rd, 1st.
    `default ITuple3<T4,T5,T3>` | `_453()` Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 3rd.
    `default ITuple5<T4,T5,T3,T1,T2>` | `_45312()` Create a new 5-tuple from this one where the elements are ordered: 4th, 5th, 3rd, 1st, 2nd.
    `default ITuple5<T4,T5,T3,T2,T1>` | `_45321()` Create a new 5-tuple from this one where the elements are ordered: 4th, 5th, 3rd, 2nd, 1st.
    `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 ITuple5<T5,T1,T2,T3,T4>` | `_51234()` Create a new 5-tuple from this one where the elements are ordered: 5th, 1st, 2nd, 3rd, 4th.
    `default ITuple5<T5,T1,T2,T4,T3>` | `_51243()` Create a new 5-tuple from this one where the elements are ordered: 5th, 1st, 2nd, 4th, 3rd.
    `default ITuple3<T5,T1,T3>` | `_513()` Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 3rd.
    `default ITuple5<T5,T1,T3,T2,T4>` | `_51324()` Create a new 5-tuple from this one where the elements are ordered: 5th, 1st, 3rd, 2nd, 4th.
    `default ITuple5<T5,T1,T3,T4,T2>` | `_51342()` Create a new 5-tuple from this one where the elements are ordered: 5th, 1st, 3rd, 4th, 2nd.
    `default ITuple3<T5,T1,T4>` | `_514()` Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 4th.
    `default ITuple5<T5,T1,T4,T2,T3>` | `_51423()` Create a new 5-tuple from this one where the elements are ordered: 5th, 1st, 4th, 2nd, 3rd.
    `default ITuple5<T5,T1,T4,T3,T2>` | `_51432()` Create a new 5-tuple from this one where the elements are ordered: 5th, 1st, 4th, 3rd, 2nd.
    `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 ITuple5<T5,T2,T1,T3,T4>` | `_52134()` Create a new 5-tuple from this one where the elements are ordered: 5th, 2nd, 1st, 3rd, 4th.
    `default ITuple5<T5,T2,T1,T4,T3>` | `_52143()` Create a new 5-tuple from this one where the elements are ordered: 5th, 2nd, 1st, 4th, 3rd.
    `default ITuple3<T5,T2,T3>` | `_523()` Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 3rd.
    `default ITuple5<T5,T2,T3,T1,T4>` | `_52314()` Create a new 5-tuple from this one where the elements are ordered: 5th, 2nd, 3rd, 1st, 4th.
    `default ITuple5<T5,T2,T3,T4,T1>` | `_52341()` Create a new 5-tuple from this one where the elements are ordered: 5th, 2nd, 3rd, 4th, 1st.
    `default ITuple3<T5,T2,T4>` | `_524()` Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 4th.
    `default ITuple5<T5,T2,T4,T1,T3>` | `_52413()` Create a new 5-tuple from this one where the elements are ordered: 5th, 2nd, 4th, 1st, 3rd.
    `default ITuple5<T5,T2,T4,T3,T1>` | `_52431()` Create a new 5-tuple from this one where the elements are ordered: 5th, 2nd, 4th, 3rd, 1st.
    `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 ITuple5<T5,T3,T1,T2,T4>` | `_53124()` Create a new 5-tuple from this one where the elements are ordered: 5th, 3rd, 1st, 2nd, 4th.
    `default ITuple5<T5,T3,T1,T4,T2>` | `_53142()` Create a new 5-tuple from this one where the elements are ordered: 5th, 3rd, 1st, 4th, 2nd.
    `default ITuple3<T5,T3,T2>` | `_532()` Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 2nd.
    `default ITuple5<T5,T3,T2,T1,T4>` | `_53214()` Create a new 5-tuple from this one where the elements are ordered: 5th, 3rd, 2nd, 1st, 4th.
    `default ITuple5<T5,T3,T2,T4,T1>` | `_53241()` Create a new 5-tuple from this one where the elements are ordered: 5th, 3rd, 2nd, 4th, 1st.
    `default ITuple3<T5,T3,T4>` | `_534()` Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 4th.
    `default ITuple5<T5,T3,T4,T1,T2>` | `_53412()` Create a new 5-tuple from this one where the elements are ordered: 5th, 3rd, 4th, 1st, 2nd.
    `default ITuple5<T5,T3,T4,T2,T1>` | `_53421()` Create a new 5-tuple from this one where the elements are ordered: 5th, 3rd, 4th, 2nd, 1st.
    `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 ITuple5<T5,T4,T1,T2,T3>` | `_54123()` Create a new 5-tuple from this one where the elements are ordered: 5th, 4th, 1st, 2nd, 3rd.
    `default ITuple5<T5,T4,T1,T3,T2>` | `_54132()` Create a new 5-tuple from this one where the elements are ordered: 5th, 4th, 1st, 3rd, 2nd.
    `default ITuple3<T5,T4,T2>` | `_542()` Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 2nd.
    `default ITuple5<T5,T4,T2,T1,T3>` | `_54213()` Create a new 5-tuple from this one where the elements are ordered: 5th, 4th, 2nd, 1st, 3rd.
    `default ITuple5<T5,T4,T2,T3,T1>` | `_54231()` Create a new 5-tuple from this one where the elements are ordered: 5th, 4th, 2nd, 3rd, 1st.
    `default ITuple3<T5,T4,T3>` | `_543()` Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 3rd.
    `default ITuple5<T5,T4,T3,T1,T2>` | `_54312()` Create a new 5-tuple from this one where the elements are ordered: 5th, 4th, 3rd, 1st, 2nd.
    `default ITuple5<T5,T4,T3,T2,T1>` | `_54321()` Create a new 5-tuple from this one where the elements are ordered: 5th, 4th, 3rd, 2nd, 1st.
    `default ITuple5.Base<T1,T2,T3,T4,T5>` | `asBase()` Convert this 5-tuple into a `base tuple` which provides useful implementations for standard methods.
    `static <S1,E1,E2,E3,E4,E5,R> java.util.function.Function<S1,R>` | `concat1(java.util.function.Function<S1,? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>> fn1, Function5<R,? super E1,? super E2,? super E3,? super E4,? super E5> fn2)` Combine a 1-argument function returning a 5-tuple with a 5-parameter function returning another result value into one 1-argument function.
    `static <S1,S2,E1,E2,E3,E4,E5,R> java.util.function.BiFunction<S1,S2,R>` | `concat2(java.util.function.BiFunction<S1,S2,? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>> fn1, Function5<R,? super E1,? super E2,? super E3,? super E4,? super E5> fn2)` Combine a 2-argument function returning a 5-tuple with a 5-parameter function returning another result value into one 2-argument function.
    `static <S1,S2,S3,E1,E2,E3,E4,E5,R> Function3<R,S1,S2,S3>` | `concat3(Function3<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3> fn1, Function5<R,? super E1,? super E2,? super E3,? super E4,? super E5> fn2)` Combine a 3-argument function returning a 5-tuple with a 5-parameter function returning another result value into one 3-argument function.
    `static <S1,S2,S3,S4,E1,E2,E3,E4,E5,R> Function4<R,S1,S2,S3,S4>` | `concat4(Function4<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4> fn1, Function5<R,? super E1,? super E2,? super E3,? super E4,? super E5> fn2)` Combine a 4-argument function returning a 5-tuple with a 5-parameter function returning another result value into one 4-argument function.
    `static <S1,S2,S3,S4,S5,E1,E2,E3,E4,E5,R> Function5<R,S1,S2,S3,S4,S5>` | `concat5(Function5<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5> fn1, Function5<R,? super E1,? super E2,? super E3,? super E4,? super E5> fn2)` Combine a 5-argument function returning a 5-tuple with a 5-parameter function returning another result value into one 5-argument function.
    `static <S1,S2,S3,S4,S5,S6,E1,E2,E3,E4,E5,R> Function6<R,S1,S2,S3,S4,S5,S6>` | `concat6(Function6<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5,S6> fn1, Function5<R,? super E1,? super E2,? super E3,? super E4,? super E5> fn2)` Combine a 6-argument function returning a 5-tuple with a 5-parameter function returning another result value into one 6-argument function.
    `static <S1,S2,S3,S4,S5,S6,S7,E1,E2,E3,E4,E5,R> Function7<R,S1,S2,S3,S4,S5,S6,S7>` | `concat7(Function7<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5,S6,S7> fn1, Function5<R,? super E1,? super E2,? super E3,? super E4,? super E5> fn2)` Combine a 7-argument function returning a 5-tuple with a 5-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,R> Function8<R,S1,S2,S3,S4,S5,S6,S7,S8>` | `concat8(Function8<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5,S6,S7,S8> fn1, Function5<R,? super E1,? super E2,? super E3,? super E4,? super E5> fn2)` Combine a 8-argument function returning a 5-tuple with a 5-parameter function returning another result value into one 8-argument function.
    `static <S1,E1,E2,E3,E4,E5> java.util.function.Predicate<S1>` | `concatPred1(java.util.function.Function<S1,? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>> fn1, Predicate5<? super E1,? super E2,? super E3,? super E4,? super E5> pred2)` Combine a 1-argument function returning a 5-tuple with a 5-parameter predicate into a 1-argument predicate.
    `static <S1,S2,E1,E2,E3,E4,E5> java.util.function.BiPredicate<S1,S2>` | `concatPred2(java.util.function.BiFunction<S1,S2,? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>> fn1, Predicate5<? super E1,? super E2,? super E3,? super E4,? super E5> pred2)` Combine a 2-argument function returning a 5-tuple with a 5-parameter predicate into a 2-argument predicate.
    `static <S1,S2,S3,E1,E2,E3,E4,E5> Predicate3<S1,S2,S3>` | `concatPred3(Function3<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3> fn1, Predicate5<? super E1,? super E2,? super E3,? super E4,? super E5> pred2)` Combine a 3-argument function returning a 5-tuple with a 5-parameter predicate into a 3-argument predicate.
    `static <S1,S2,S3,S4,E1,E2,E3,E4,E5> Predicate4<S1,S2,S3,S4>` | `concatPred4(Function4<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4> fn1, Predicate5<? super E1,? super E2,? super E3,? super E4,? super E5> pred2)` Combine a 4-argument function returning a 5-tuple with a 5-parameter predicate into a 4-argument predicate.
    `static <S1,S2,S3,S4,S5,E1,E2,E3,E4,E5> Predicate5<S1,S2,S3,S4,S5>` | `concatPred5(Function5<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5> fn1, Predicate5<? super E1,? super E2,? super E3,? super E4,? super E5> pred2)` Combine a 5-argument function returning a 5-tuple with a 5-parameter predicate into a 5-argument predicate.
    `static <S1,S2,S3,S4,S5,S6,E1,E2,E3,E4,E5> Predicate6<S1,S2,S3,S4,S5,S6>` | `concatPred6(Function6<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5,S6> fn1, Predicate5<? super E1,? super E2,? super E3,? super E4,? super E5> pred2)` Combine a 6-argument function returning a 5-tuple with a 5-parameter predicate into a 6-argument predicate.
    `static <S1,S2,S3,S4,S5,S6,S7,E1,E2,E3,E4,E5> Predicate7<S1,S2,S3,S4,S5,S6,S7>` | `concatPred7(Function7<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5,S6,S7> fn1, Predicate5<? super E1,? super E2,? super E3,? super E4,? super E5> pred2)` Combine a 7-argument function returning a 5-tuple with a 5-parameter predicate into a 7-argument predicate.
    `static <S1,S2,S3,S4,S5,S6,S7,S8,E1,E2,E3,E4,E5> Predicate8<S1,S2,S3,S4,S5,S6,S7,S8>` | `concatPred8(Function8<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5,S6,S7,S8> fn1, Predicate5<? super E1,? super E2,? super E3,? super E4,? super E5> pred2)` Combine a 8-argument function returning a 5-tuple with a 5-parameter predicate into a 8-argument predicate.
    `static <S1,E1,E2,E3,E4,E5> java.util.function.Consumer<S1>` | `concatProc1(java.util.function.Function<S1,? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>> fn1, Procedure5<? super E1,? super E2,? super E3,? super E4,? super E5> proc2)` Combine a 1-argument function returning a 5-tuple with a 5-parameter consumer/procedure into a 1-argument consumer/procedure.
    `static <S1,S2,E1,E2,E3,E4,E5> java.util.function.BiConsumer<S1,S2>` | `concatProc2(java.util.function.BiFunction<S1,S2,? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>> fn1, Procedure5<? super E1,? super E2,? super E3,? super E4,? super E5> proc2)` Combine a 2-argument function returning a 5-tuple with a 5-parameter consumer/procedure into a 2-argument consumer/procedure.
    `static <S1,S2,S3,E1,E2,E3,E4,E5> Procedure3<S1,S2,S3>` | `concatProc3(Function3<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3> fn1, Procedure5<? super E1,? super E2,? super E3,? super E4,? super E5> proc2)` Combine a 3-argument function returning a 5-tuple with a 5-parameter consumer/procedure into a 3-argument consumer/procedure.
    `static <S1,S2,S3,S4,E1,E2,E3,E4,E5> Procedure4<S1,S2,S3,S4>` | `concatProc4(Function4<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4> fn1, Procedure5<? super E1,? super E2,? super E3,? super E4,? super E5> proc2)` Combine a 4-argument function returning a 5-tuple with a 5-parameter consumer/procedure into a 4-argument consumer/procedure.
    `static <S1,S2,S3,S4,S5,E1,E2,E3,E4,E5> Procedure5<S1,S2,S3,S4,S5>` | `concatProc5(Function5<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5> fn1, Procedure5<? super E1,? super E2,? super E3,? super E4,? super E5> proc2)` Combine a 5-argument function returning a 5-tuple with a 5-parameter consumer/procedure into a 5-argument consumer/procedure.
    `static <S1,S2,S3,S4,S5,S6,E1,E2,E3,E4,E5> Procedure6<S1,S2,S3,S4,S5,S6>` | `concatProc6(Function6<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5,S6> fn1, Procedure5<? super E1,? super E2,? super E3,? super E4,? super E5> proc2)` Combine a 6-argument function returning a 5-tuple with a 5-parameter consumer/procedure into a 6-argument consumer/procedure.
    `static <S1,S2,S3,S4,S5,S6,S7,E1,E2,E3,E4,E5> Procedure7<S1,S2,S3,S4,S5,S6,S7>` | `concatProc7(Function7<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5,S6,S7> fn1, Procedure5<? super E1,? super E2,? super E3,? super E4,? super E5> proc2)` Combine a 7-argument function returning a 5-tuple with a 5-parameter consumer/procedure into a 7-argument consumer/procedure.
    `static <S1,S2,S3,S4,S5,S6,S7,S8,E1,E2,E3,E4,E5> Procedure8<S1,S2,S3,S4,S5,S6,S7,S8>` | `concatProc8(Function8<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5,S6,S7,S8> fn1, Procedure5<? super E1,? super E2,? super E3,? super E4,? super E5> proc2)` Combine a 8-argument function returning a 5-tuple with a 5-parameter consumer/procedure into a 8-argument consumer/procedure.
    `static boolean` | `equals(ITuple5<?,?,?,?,?> tuple, java.lang.Object o)` Basic implementation of equals for 5-tuples.
    `default NTuple5<T1,T2,T3,T4,T5>` | `frozen()` Convert this into an object of a concrete tuple implementation.
    `default Tuple5<T1,T2,T3,T4,T5>` | `frozenNotNull()` Convert this into an object of a concrete tuple implementation.
    `static int` | `hash(ITuple5<?,?,?,?,?> tuple)` Basic implementation for calculating a hash code of a 5-tuple.
    `default <T> T` | `invoke(Function5<T,? super T1,? super T2,? super T3,? super T4,? super T5> function)` Invoke a %d-argument function on this tuple.
    `default void` | `sendTo(Procedure5<? super T1,? super T2,? super T3,? super T4,? super T5> procedure)` Send this tuple unpacked to a 5-argument procedure.
    `default boolean` | `testBy(Predicate5<? super T1,? super T2,? super T3,? super T4,? super T5> predicate)` Test a 5-argument predicate with this tuple unpacked.
    `static java.lang.String` | `toString(ITuple5<?,?,?,?,?> tuple)` Basic implementation for creating a string from a 5-tuple.
    `static java.lang.String` | `toString(java.lang.String prefix, ITuple5<?,?,?,?,?> tuple)` Basic implementation for creating a string from a 5-tuple.
    `static <E1,E2,E3,E4,E5> ITuple5<E1,E2,E3,E4,E5>` | `view(E1 elem1, E2 elem2, E3 elem3, E4 elem4, E5 elem5)` Create a new 5-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

    - #### _12354

          @NotNull
          default ITuple5<T1,T2,T3,T5,T4> _12354()

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

    - #### _12534

          @NotNull
          default ITuple5<T1,T2,T5,T3,T4> _12534()

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

    - #### _15234

          @NotNull
          default ITuple5<T1,T5,T2,T3,T4> _15234()

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

    - #### _51234

          @NotNull
          default ITuple5<T5,T1,T2,T3,T4> _51234()

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

    - #### _51243

          @NotNull
          default ITuple5<T5,T1,T2,T4,T3> _51243()

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

    - #### _15243

          @NotNull
          default ITuple5<T1,T5,T2,T4,T3> _15243()

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

    - #### _12543

          @NotNull
          default ITuple5<T1,T2,T5,T4,T3> _12543()

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

    - #### _12453

          @NotNull
          default ITuple5<T1,T2,T4,T5,T3> _12453()

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

    - #### _12435

          @NotNull
          default ITuple5<T1,T2,T4,T3,T5> _12435()

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

    - #### _14235

          @NotNull
          default ITuple5<T1,T4,T2,T3,T5> _14235()

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

    - #### _14253

          @NotNull
          default ITuple5<T1,T4,T2,T5,T3> _14253()

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

    - #### _14523

          @NotNull
          default ITuple5<T1,T4,T5,T2,T3> _14523()

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

    - #### _15423

          @NotNull
          default ITuple5<T1,T5,T4,T2,T3> _15423()

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

    - #### _51423

          @NotNull
          default ITuple5<T5,T1,T4,T2,T3> _51423()

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

    - #### _54123

          @NotNull
          default ITuple5<T5,T4,T1,T2,T3> _54123()

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

    - #### _45123

          @NotNull
          default ITuple5<T4,T5,T1,T2,T3> _45123()

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

    - #### _41523

          @NotNull
          default ITuple5<T4,T1,T5,T2,T3> _41523()

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

    - #### _41253

          @NotNull
          default ITuple5<T4,T1,T2,T5,T3> _41253()

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

    - #### _41235

          @NotNull
          default ITuple5<T4,T1,T2,T3,T5> _41235()

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

    - #### _41325

          @NotNull
          default ITuple5<T4,T1,T3,T2,T5> _41325()

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

    - #### _41352

          @NotNull
          default ITuple5<T4,T1,T3,T5,T2> _41352()

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

    - #### _41532

          @NotNull
          default ITuple5<T4,T1,T5,T3,T2> _41532()

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

    - #### _45132

          @NotNull
          default ITuple5<T4,T5,T1,T3,T2> _45132()

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

    - #### _54132

          @NotNull
          default ITuple5<T5,T4,T1,T3,T2> _54132()

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

    - #### _51432

          @NotNull
          default ITuple5<T5,T1,T4,T3,T2> _51432()

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

    - #### _15432

          @NotNull
          default ITuple5<T1,T5,T4,T3,T2> _15432()

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

    - #### _14532

          @NotNull
          default ITuple5<T1,T4,T5,T3,T2> _14532()

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

    - #### _14352

          @NotNull
          default ITuple5<T1,T4,T3,T5,T2> _14352()

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

    - #### _14325

          @NotNull
          default ITuple5<T1,T4,T3,T2,T5> _14325()

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

    - #### _13425

          @NotNull
          default ITuple5<T1,T3,T4,T2,T5> _13425()

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

    - #### _13452

          @NotNull
          default ITuple5<T1,T3,T4,T5,T2> _13452()

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

    - #### _13542

          @NotNull
          default ITuple5<T1,T3,T5,T4,T2> _13542()

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

    - #### _15342

          @NotNull
          default ITuple5<T1,T5,T3,T4,T2> _15342()

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

    - #### _51342

          @NotNull
          default ITuple5<T5,T1,T3,T4,T2> _51342()

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

    - #### _51324

          @NotNull
          default ITuple5<T5,T1,T3,T2,T4> _51324()

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

    - #### _15324

          @NotNull
          default ITuple5<T1,T5,T3,T2,T4> _15324()

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

    - #### _13524

          @NotNull
          default ITuple5<T1,T3,T5,T2,T4> _13524()

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

    - #### _13254

          @NotNull
          default ITuple5<T1,T3,T2,T5,T4> _13254()

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

    - #### _13245

          @NotNull
          default ITuple5<T1,T3,T2,T4,T5> _13245()

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

    - #### _31245

          @NotNull
          default ITuple5<T3,T1,T2,T4,T5> _31245()

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

    - #### _31254

          @NotNull
          default ITuple5<T3,T1,T2,T5,T4> _31254()

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

    - #### _31524

          @NotNull
          default ITuple5<T3,T1,T5,T2,T4> _31524()

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

    - #### _35124

          @NotNull
          default ITuple5<T3,T5,T1,T2,T4> _35124()

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

    - #### _53124

          @NotNull
          default ITuple5<T5,T3,T1,T2,T4> _53124()

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

    - #### _53142

          @NotNull
          default ITuple5<T5,T3,T1,T4,T2> _53142()

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

    - #### _35142

          @NotNull
          default ITuple5<T3,T5,T1,T4,T2> _35142()

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

    - #### _31542

          @NotNull
          default ITuple5<T3,T1,T5,T4,T2> _31542()

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

    - #### _31452

          @NotNull
          default ITuple5<T3,T1,T4,T5,T2> _31452()

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

    - #### _31425

          @NotNull
          default ITuple5<T3,T1,T4,T2,T5> _31425()

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

    - #### _34125

          @NotNull
          default ITuple5<T3,T4,T1,T2,T5> _34125()

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

    - #### _34152

          @NotNull
          default ITuple5<T3,T4,T1,T5,T2> _34152()

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

    - #### _34512

          @NotNull
          default ITuple5<T3,T4,T5,T1,T2> _34512()

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

    - #### _35412

          @NotNull
          default ITuple5<T3,T5,T4,T1,T2> _35412()

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

    - #### _53412

          @NotNull
          default ITuple5<T5,T3,T4,T1,T2> _53412()

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

    - #### _54312

          @NotNull
          default ITuple5<T5,T4,T3,T1,T2> _54312()

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

    - #### _45312

          @NotNull
          default ITuple5<T4,T5,T3,T1,T2> _45312()

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

    - #### _43512

          @NotNull
          default ITuple5<T4,T3,T5,T1,T2> _43512()

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

    - #### _43152

          @NotNull
          default ITuple5<T4,T3,T1,T5,T2> _43152()

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

    - #### _43125

          @NotNull
          default ITuple5<T4,T3,T1,T2,T5> _43125()

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

    - #### _43215

          @NotNull
          default ITuple5<T4,T3,T2,T1,T5> _43215()

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

    - #### _43251

          @NotNull
          default ITuple5<T4,T3,T2,T5,T1> _43251()

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

    - #### _43521

          @NotNull
          default ITuple5<T4,T3,T5,T2,T1> _43521()

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

    - #### _45321

          @NotNull
          default ITuple5<T4,T5,T3,T2,T1> _45321()

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

    - #### _54321

          @NotNull
          default ITuple5<T5,T4,T3,T2,T1> _54321()

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

    - #### _53421

          @NotNull
          default ITuple5<T5,T3,T4,T2,T1> _53421()

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

    - #### _35421

          @NotNull
          default ITuple5<T3,T5,T4,T2,T1> _35421()

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

    - #### _34521

          @NotNull
          default ITuple5<T3,T4,T5,T2,T1> _34521()

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

    - #### _34251

          @NotNull
          default ITuple5<T3,T4,T2,T5,T1> _34251()

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

    - #### _34215

          @NotNull
          default ITuple5<T3,T4,T2,T1,T5> _34215()

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

    - #### _32415

          @NotNull
          default ITuple5<T3,T2,T4,T1,T5> _32415()

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

    - #### _32451

          @NotNull
          default ITuple5<T3,T2,T4,T5,T1> _32451()

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

    - #### _32541

          @NotNull
          default ITuple5<T3,T2,T5,T4,T1> _32541()

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

    - #### _35241

          @NotNull
          default ITuple5<T3,T5,T2,T4,T1> _35241()

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

    - #### _53241

          @NotNull
          default ITuple5<T5,T3,T2,T4,T1> _53241()

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

    - #### _53214

          @NotNull
          default ITuple5<T5,T3,T2,T1,T4> _53214()

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

    - #### _35214

          @NotNull
          default ITuple5<T3,T5,T2,T1,T4> _35214()

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

    - #### _32514

          @NotNull
          default ITuple5<T3,T2,T5,T1,T4> _32514()

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

    - #### _32154

          @NotNull
          default ITuple5<T3,T2,T1,T5,T4> _32154()

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

    - #### _32145

          @NotNull
          default ITuple5<T3,T2,T1,T4,T5> _32145()

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

    - #### _23145

          @NotNull
          default ITuple5<T2,T3,T1,T4,T5> _23145()

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

    - #### _23154

          @NotNull
          default ITuple5<T2,T3,T1,T5,T4> _23154()

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

    - #### _23514

          @NotNull
          default ITuple5<T2,T3,T5,T1,T4> _23514()

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

    - #### _25314

          @NotNull
          default ITuple5<T2,T5,T3,T1,T4> _25314()

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

    - #### _52314

          @NotNull
          default ITuple5<T5,T2,T3,T1,T4> _52314()

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

    - #### _52341

          @NotNull
          default ITuple5<T5,T2,T3,T4,T1> _52341()

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

    - #### _25341

          @NotNull
          default ITuple5<T2,T5,T3,T4,T1> _25341()

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

    - #### _23541

          @NotNull
          default ITuple5<T2,T3,T5,T4,T1> _23541()

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

    - #### _23451

          @NotNull
          default ITuple5<T2,T3,T4,T5,T1> _23451()

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

    - #### _23415

          @NotNull
          default ITuple5<T2,T3,T4,T1,T5> _23415()

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

    - #### _24315

          @NotNull
          default ITuple5<T2,T4,T3,T1,T5> _24315()

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

    - #### _24351

          @NotNull
          default ITuple5<T2,T4,T3,T5,T1> _24351()

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

    - #### _24531

          @NotNull
          default ITuple5<T2,T4,T5,T3,T1> _24531()

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

    - #### _25431

          @NotNull
          default ITuple5<T2,T5,T4,T3,T1> _25431()

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

    - #### _52431

          @NotNull
          default ITuple5<T5,T2,T4,T3,T1> _52431()

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

    - #### _54231

          @NotNull
          default ITuple5<T5,T4,T2,T3,T1> _54231()

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

    - #### _45231

          @NotNull
          default ITuple5<T4,T5,T2,T3,T1> _45231()

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

    - #### _42531

          @NotNull
          default ITuple5<T4,T2,T5,T3,T1> _42531()

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

    - #### _42351

          @NotNull
          default ITuple5<T4,T2,T3,T5,T1> _42351()

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

    - #### _42315

          @NotNull
          default ITuple5<T4,T2,T3,T1,T5> _42315()

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

    - #### _42135

          @NotNull
          default ITuple5<T4,T2,T1,T3,T5> _42135()

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

    - #### _42153

          @NotNull
          default ITuple5<T4,T2,T1,T5,T3> _42153()

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

    - #### _42513

          @NotNull
          default ITuple5<T4,T2,T5,T1,T3> _42513()

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

    - #### _45213

          @NotNull
          default ITuple5<T4,T5,T2,T1,T3> _45213()

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

    - #### _54213

          @NotNull
          default ITuple5<T5,T4,T2,T1,T3> _54213()

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

    - #### _52413

          @NotNull
          default ITuple5<T5,T2,T4,T1,T3> _52413()

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

    - #### _25413

          @NotNull
          default ITuple5<T2,T5,T4,T1,T3> _25413()

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

    - #### _24513

          @NotNull
          default ITuple5<T2,T4,T5,T1,T3> _24513()

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

    - #### _24153

          @NotNull
          default ITuple5<T2,T4,T1,T5,T3> _24153()

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

    - #### _24135

          @NotNull
          default ITuple5<T2,T4,T1,T3,T5> _24135()

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

    - #### _21435

          @NotNull
          default ITuple5<T2,T1,T4,T3,T5> _21435()

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

    - #### _21453

          @NotNull
          default ITuple5<T2,T1,T4,T5,T3> _21453()

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

    - #### _21543

          @NotNull
          default ITuple5<T2,T1,T5,T4,T3> _21543()

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

    - #### _25143

          @NotNull
          default ITuple5<T2,T5,T1,T4,T3> _25143()

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

    - #### _52143

          @NotNull
          default ITuple5<T5,T2,T1,T4,T3> _52143()

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

    - #### _52134

          @NotNull
          default ITuple5<T5,T2,T1,T3,T4> _52134()

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

    - #### _25134

          @NotNull
          default ITuple5<T2,T5,T1,T3,T4> _25134()

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

    - #### _21534

          @NotNull
          default ITuple5<T2,T1,T5,T3,T4> _21534()

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

    - #### _21354

          @NotNull
          default ITuple5<T2,T1,T3,T5,T4> _21354()

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

    - #### _21345

          @NotNull
          default ITuple5<T2,T1,T3,T4,T5> _21345()

      Create a new 5-tuple from this one where the elements are ordered: 2nd, 1st, 3rd, 4th, 5th.
      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

    - #### _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

    - #### _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

    - #### asBase

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

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

    - #### frozen

          @NotNull
          default NTuple5<T1,T2,T3,T4,T5> 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 Tuple5<T1,T2,T3,T4,T5> 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
                               Function5<T,? super T1,? super T2,? super T3,? super T4,? super T5> 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
                              Procedure5<? super T1,? super T2,? super T3,? super T4,? super T5> procedure)

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

    - #### testBy

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

      Test a 5-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> ITuple5<E1,E2,E3,E4,E5> view(E1 elem1,
                                                                        E2 elem2,
                                                                        E3 elem3,
                                                                        E4 elem4,
                                                                        E5 elem5)

      Create a new 5-tuple on the fly. This is especially useful for temporary usage, you might want to create a `Tuple5` instead as that gives guarantees of the non-nullness of its elements, or a `NTuple5` as that at least is serializable (as is `Tuple5`).
      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
      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
      Returns:
        5-tuple view of the given elements

    - #### equals

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

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

    - #### hash

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

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

    - #### toString

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

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

    - #### toString

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

      Basic implementation for creating a string from a 5-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(ITuple5)`

    - #### concat1

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

      Combine a 1-argument function returning a 5-tuple with a 5-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
        `R` - result type
      Parameters:
        `fn1` - 1-argument function returning a 5-tuple
        `fn2` - 5-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> java.util.function.Consumer<S1> concatProc1(@NotNull
                                                                                          java.util.function.Function<S1,? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>> fn1,
                                                                                          @NotNull
                                                                                          Procedure5<? super E1,? super E2,? super E3,? super E4,? super E5> proc2)

      Combine a 1-argument function returning a 5-tuple with a 5-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
      Parameters:
        `fn1` - 1-argument function returning a 5-tuple
        `proc2` - 5-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> java.util.function.Predicate<S1> concatPred1(@NotNull
                                                                                           java.util.function.Function<S1,? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>> fn1,
                                                                                           @NotNull
                                                                                           Predicate5<? super E1,? super E2,? super E3,? super E4,? super E5> pred2)

      Combine a 1-argument function returning a 5-tuple with a 5-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
      Parameters:
        `fn1` - 1-argument function returning a 5-tuple
        `pred2` - 5-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,R> java.util.function.BiFunction<S1,S2,R> concat2(@NotNull
                                                                                                  java.util.function.BiFunction<S1,S2,? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>> fn1,
                                                                                                  @NotNull
                                                                                                  Function5<R,? super E1,? super E2,? super E3,? super E4,? super E5> fn2)

      Combine a 2-argument function returning a 5-tuple with a 5-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
        `R` - result type
      Parameters:
        `fn1` - 2-argument function returning a 5-tuple
        `fn2` - 5-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> java.util.function.BiConsumer<S1,S2> concatProc2(@NotNull
                                                                                                  java.util.function.BiFunction<S1,S2,? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>> fn1,
                                                                                                  @NotNull
                                                                                                  Procedure5<? super E1,? super E2,? super E3,? super E4,? super E5> proc2)

      Combine a 2-argument function returning a 5-tuple with a 5-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
      Parameters:
        `fn1` - 2-argument function returning a 5-tuple
        `proc2` - 5-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> java.util.function.BiPredicate<S1,S2> concatPred2(@NotNull
                                                                                                   java.util.function.BiFunction<S1,S2,? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>> fn1,
                                                                                                   @NotNull
                                                                                                   Predicate5<? super E1,? super E2,? super E3,? super E4,? super E5> pred2)

      Combine a 2-argument function returning a 5-tuple with a 5-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
      Parameters:
        `fn1` - 2-argument function returning a 5-tuple
        `pred2` - 5-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,R> Function3<R,S1,S2,S3> concat3(@NotNull
                                                                                    Function3<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3> fn1,
                                                                                    @NotNull
                                                                                    Function5<R,? super E1,? super E2,? super E3,? super E4,? super E5> fn2)

      Combine a 3-argument function returning a 5-tuple with a 5-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
        `R` - result type
      Parameters:
        `fn1` - 3-argument function returning a 5-tuple
        `fn2` - 5-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> Procedure3<S1,S2,S3> concatProc3(@NotNull
                                                                                     Function3<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3> fn1,
                                                                                     @NotNull
                                                                                     Procedure5<? super E1,? super E2,? super E3,? super E4,? super E5> proc2)

      Combine a 3-argument function returning a 5-tuple with a 5-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
      Parameters:
        `fn1` - 3-argument function returning a 5-tuple
        `proc2` - 5-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> Predicate3<S1,S2,S3> concatPred3(@NotNull
                                                                                     Function3<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3> fn1,
                                                                                     @NotNull
                                                                                     Predicate5<? super E1,? super E2,? super E3,? super E4,? super E5> pred2)

      Combine a 3-argument function returning a 5-tuple with a 5-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
      Parameters:
        `fn1` - 3-argument function returning a 5-tuple
        `pred2` - 5-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,R> Function4<R,S1,S2,S3,S4> concat4(@NotNull
                                                                                          Function4<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4> fn1,
                                                                                          @NotNull
                                                                                          Function5<R,? super E1,? super E2,? super E3,? super E4,? super E5> fn2)

      Combine a 4-argument function returning a 5-tuple with a 5-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
        `R` - result type
      Parameters:
        `fn1` - 4-argument function returning a 5-tuple
        `fn2` - 5-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> Procedure4<S1,S2,S3,S4> concatProc4(@NotNull
                                                                                           Function4<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4> fn1,
                                                                                           @NotNull
                                                                                           Procedure5<? super E1,? super E2,? super E3,? super E4,? super E5> proc2)

      Combine a 4-argument function returning a 5-tuple with a 5-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
      Parameters:
        `fn1` - 4-argument function returning a 5-tuple
        `proc2` - 5-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> Predicate4<S1,S2,S3,S4> concatPred4(@NotNull
                                                                                           Function4<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4> fn1,
                                                                                           @NotNull
                                                                                           Predicate5<? super E1,? super E2,? super E3,? super E4,? super E5> pred2)

      Combine a 4-argument function returning a 5-tuple with a 5-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
      Parameters:
        `fn1` - 4-argument function returning a 5-tuple
        `pred2` - 5-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,R> Function5<R,S1,S2,S3,S4,S5> concat5(@NotNull
                                                                                                Function5<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5> fn1,
                                                                                                @NotNull
                                                                                                Function5<R,? super E1,? super E2,? super E3,? super E4,? super E5> fn2)

      Combine a 5-argument function returning a 5-tuple with a 5-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
        `R` - result type
      Parameters:
        `fn1` - 5-argument function returning a 5-tuple
        `fn2` - 5-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> Procedure5<S1,S2,S3,S4,S5> concatProc5(@NotNull
                                                                                                 Function5<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5> fn1,
                                                                                                 @NotNull
                                                                                                 Procedure5<? super E1,? super E2,? super E3,? super E4,? super E5> proc2)

      Combine a 5-argument function returning a 5-tuple with a 5-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
      Parameters:
        `fn1` - 5-argument function returning a 5-tuple
        `proc2` - 5-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> Predicate5<S1,S2,S3,S4,S5> concatPred5(@NotNull
                                                                                                 Function5<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5> fn1,
                                                                                                 @NotNull
                                                                                                 Predicate5<? super E1,? super E2,? super E3,? super E4,? super E5> pred2)

      Combine a 5-argument function returning a 5-tuple with a 5-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
      Parameters:
        `fn1` - 5-argument function returning a 5-tuple
        `pred2` - 5-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,R> Function6<R,S1,S2,S3,S4,S5,S6> concat6(@NotNull
                                                                                                      Function6<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5,S6> fn1,
                                                                                                      @NotNull
                                                                                                      Function5<R,? super E1,? super E2,? super E3,? super E4,? super E5> fn2)

      Combine a 6-argument function returning a 5-tuple with a 5-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
        `R` - result type
      Parameters:
        `fn1` - 6-argument function returning a 5-tuple
        `fn2` - 5-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> Procedure6<S1,S2,S3,S4,S5,S6> concatProc6(@NotNull
                                                                                                       Function6<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5,S6> fn1,
                                                                                                       @NotNull
                                                                                                       Procedure5<? super E1,? super E2,? super E3,? super E4,? super E5> proc2)

      Combine a 6-argument function returning a 5-tuple with a 5-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
      Parameters:
        `fn1` - 6-argument function returning a 5-tuple
        `proc2` - 5-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> Predicate6<S1,S2,S3,S4,S5,S6> concatPred6(@NotNull
                                                                                                       Function6<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5,S6> fn1,
                                                                                                       @NotNull
                                                                                                       Predicate5<? super E1,? super E2,? super E3,? super E4,? super E5> pred2)

      Combine a 6-argument function returning a 5-tuple with a 5-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
      Parameters:
        `fn1` - 6-argument function returning a 5-tuple
        `pred2` - 5-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,R> Function7<R,S1,S2,S3,S4,S5,S6,S7> concat7(@NotNull
                                                                                                            Function7<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5,S6,S7> fn1,
                                                                                                            @NotNull
                                                                                                            Function5<R,? super E1,? super E2,? super E3,? super E4,? super E5> fn2)

      Combine a 7-argument function returning a 5-tuple with a 5-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
        `R` - result type
      Parameters:
        `fn1` - 7-argument function returning a 5-tuple
        `fn2` - 5-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> Procedure7<S1,S2,S3,S4,S5,S6,S7> concatProc7(@NotNull
                                                                                                             Function7<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5,S6,S7> fn1,
                                                                                                             @NotNull
                                                                                                             Procedure5<? super E1,? super E2,? super E3,? super E4,? super E5> proc2)

      Combine a 7-argument function returning a 5-tuple with a 5-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
      Parameters:
        `fn1` - 7-argument function returning a 5-tuple
        `proc2` - 5-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> Predicate7<S1,S2,S3,S4,S5,S6,S7> concatPred7(@NotNull
                                                                                                             Function7<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5,S6,S7> fn1,
                                                                                                             @NotNull
                                                                                                             Predicate5<? super E1,? super E2,? super E3,? super E4,? super E5> pred2)

      Combine a 7-argument function returning a 5-tuple with a 5-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
      Parameters:
        `fn1` - 7-argument function returning a 5-tuple
        `pred2` - 5-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,R> Function8<R,S1,S2,S3,S4,S5,S6,S7,S8> concat8(@NotNull
                                                                                                                  Function8<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5,S6,S7,S8> fn1,
                                                                                                                  @NotNull
                                                                                                                  Function5<R,? super E1,? super E2,? super E3,? super E4,? super E5> fn2)

      Combine a 8-argument function returning a 5-tuple with a 5-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
        `R` - result type
      Parameters:
        `fn1` - 8-argument function returning a 5-tuple
        `fn2` - 5-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> Procedure8<S1,S2,S3,S4,S5,S6,S7,S8> concatProc8(@NotNull
                                                                                                                   Function8<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5,S6,S7,S8> fn1,
                                                                                                                   @NotNull
                                                                                                                   Procedure5<? super E1,? super E2,? super E3,? super E4,? super E5> proc2)

      Combine a 8-argument function returning a 5-tuple with a 5-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
      Parameters:
        `fn1` - 8-argument function returning a 5-tuple
        `proc2` - 5-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> Predicate8<S1,S2,S3,S4,S5,S6,S7,S8> concatPred8(@NotNull
                                                                                                                   Function8<? extends ITuple5<? extends E1,? extends E2,? extends E3,? extends E4,? extends E5>,S1,S2,S3,S4,S5,S6,S7,S8> fn1,
                                                                                                                   @NotNull
                                                                                                                   Predicate5<? super E1,? super E2,? super E3,? super E4,? super E5> pred2)

      Combine a 8-argument function returning a 5-tuple with a 5-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
      Parameters:
        `fn1` - 8-argument function returning a 5-tuple
        `pred2` - 5-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`