Class Quintet<A,​B,​C,​D,​E>

    • Constructor Summary

      Constructors 
      Constructor Description
      Quintet​(A value0, B value1, C value2, D value3, E value4)  
    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      <X0,​X1>
      Septet<A,​B,​C,​D,​E,​X0,​X1>
      add​(Pair<X0,​X1> tuple)  
      <X0,​X1,​X2,​X3>
      Ennead<A,​B,​C,​D,​E,​X0,​X1,​X2,​X3>
      add​(Quartet<X0,​X1,​X2,​X3> tuple)  
      <X0,​X1,​X2,​X3,​X4>
      Decade<A,​B,​C,​D,​E,​X0,​X1,​X2,​X3,​X4>
      add​(Quintet<X0,​X1,​X2,​X3,​X4> tuple)  
      <X0,​X1,​X2>
      Octet<A,​B,​C,​D,​E,​X0,​X1,​X2>
      add​(Triplet<X0,​X1,​X2> tuple)  
      <X0> Sextet<A,​B,​C,​D,​E,​X0> add​(Unit<X0> tuple)  
      <X0> Sextet<A,​B,​C,​D,​E,​X0> add​(X0 value0)  
      <X0,​X1>
      Septet<A,​B,​C,​D,​E,​X0,​X1>
      add​(X0 value0, X1 value1)  
      <X0,​X1,​X2>
      Octet<A,​B,​C,​D,​E,​X0,​X1,​X2>
      add​(X0 value0, X1 value1, X2 value2)  
      <X0,​X1,​X2,​X3>
      Ennead<A,​B,​C,​D,​E,​X0,​X1,​X2,​X3>
      add​(X0 value0, X1 value1, X2 value2, X3 value3)  
      <X0,​X1,​X2,​X3,​X4>
      Decade<A,​B,​C,​D,​E,​X0,​X1,​X2,​X3,​X4>
      add​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4)  
      <X0,​X1>
      Septet<X0,​X1,​A,​B,​C,​D,​E>
      addAt0​(Pair<X0,​X1> tuple)  
      <X0,​X1,​X2,​X3>
      Ennead<X0,​X1,​X2,​X3,​A,​B,​C,​D,​E>
      addAt0​(Quartet<X0,​X1,​X2,​X3> tuple)  
      <X0,​X1,​X2,​X3,​X4>
      Decade<X0,​X1,​X2,​X3,​X4,​A,​B,​C,​D,​E>
      addAt0​(Quintet<X0,​X1,​X2,​X3,​X4> tuple)  
      <X0,​X1,​X2>
      Octet<X0,​X1,​X2,​A,​B,​C,​D,​E>
      addAt0​(Triplet<X0,​X1,​X2> tuple)  
      <X0> Sextet<X0,​A,​B,​C,​D,​E> addAt0​(Unit<X0> tuple)  
      <X0> Sextet<X0,​A,​B,​C,​D,​E> addAt0​(X0 value0)  
      <X0,​X1>
      Septet<X0,​X1,​A,​B,​C,​D,​E>
      addAt0​(X0 value0, X1 value1)  
      <X0,​X1,​X2>
      Octet<X0,​X1,​X2,​A,​B,​C,​D,​E>
      addAt0​(X0 value0, X1 value1, X2 value2)  
      <X0,​X1,​X2,​X3>
      Ennead<X0,​X1,​X2,​X3,​A,​B,​C,​D,​E>
      addAt0​(X0 value0, X1 value1, X2 value2, X3 value3)  
      <X0,​X1,​X2,​X3,​X4>
      Decade<X0,​X1,​X2,​X3,​X4,​A,​B,​C,​D,​E>
      addAt0​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4)  
      <X0,​X1>
      Septet<A,​X0,​X1,​B,​C,​D,​E>
      addAt1​(Pair<X0,​X1> tuple)  
      <X0,​X1,​X2,​X3>
      Ennead<A,​X0,​X1,​X2,​X3,​B,​C,​D,​E>
      addAt1​(Quartet<X0,​X1,​X2,​X3> tuple)  
      <X0,​X1,​X2,​X3,​X4>
      Decade<A,​X0,​X1,​X2,​X3,​X4,​B,​C,​D,​E>
      addAt1​(Quintet<X0,​X1,​X2,​X3,​X4> tuple)  
      <X0,​X1,​X2>
      Octet<A,​X0,​X1,​X2,​B,​C,​D,​E>
      addAt1​(Triplet<X0,​X1,​X2> tuple)  
      <X0> Sextet<A,​X0,​B,​C,​D,​E> addAt1​(Unit<X0> tuple)  
      <X0> Sextet<A,​X0,​B,​C,​D,​E> addAt1​(X0 value0)  
      <X0,​X1>
      Septet<A,​X0,​X1,​B,​C,​D,​E>
      addAt1​(X0 value0, X1 value1)  
      <X0,​X1,​X2>
      Octet<A,​X0,​X1,​X2,​B,​C,​D,​E>
      addAt1​(X0 value0, X1 value1, X2 value2)  
      <X0,​X1,​X2,​X3>
      Ennead<A,​X0,​X1,​X2,​X3,​B,​C,​D,​E>
      addAt1​(X0 value0, X1 value1, X2 value2, X3 value3)  
      <X0,​X1,​X2,​X3,​X4>
      Decade<A,​X0,​X1,​X2,​X3,​X4,​B,​C,​D,​E>
      addAt1​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4)  
      <X0,​X1>
      Septet<A,​B,​X0,​X1,​C,​D,​E>
      addAt2​(Pair<X0,​X1> tuple)  
      <X0,​X1,​X2,​X3>
      Ennead<A,​B,​X0,​X1,​X2,​X3,​C,​D,​E>
      addAt2​(Quartet<X0,​X1,​X2,​X3> tuple)  
      <X0,​X1,​X2,​X3,​X4>
      Decade<A,​B,​X0,​X1,​X2,​X3,​X4,​C,​D,​E>
      addAt2​(Quintet<X0,​X1,​X2,​X3,​X4> tuple)  
      <X0,​X1,​X2>
      Octet<A,​B,​X0,​X1,​X2,​C,​D,​E>
      addAt2​(Triplet<X0,​X1,​X2> tuple)  
      <X0> Sextet<A,​B,​X0,​C,​D,​E> addAt2​(Unit<X0> tuple)  
      <X0> Sextet<A,​B,​X0,​C,​D,​E> addAt2​(X0 value0)  
      <X0,​X1>
      Septet<A,​B,​X0,​X1,​C,​D,​E>
      addAt2​(X0 value0, X1 value1)  
      <X0,​X1,​X2>
      Octet<A,​B,​X0,​X1,​X2,​C,​D,​E>
      addAt2​(X0 value0, X1 value1, X2 value2)  
      <X0,​X1,​X2,​X3>
      Ennead<A,​B,​X0,​X1,​X2,​X3,​C,​D,​E>
      addAt2​(X0 value0, X1 value1, X2 value2, X3 value3)  
      <X0,​X1,​X2,​X3,​X4>
      Decade<A,​B,​X0,​X1,​X2,​X3,​X4,​C,​D,​E>
      addAt2​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4)  
      <X0,​X1>
      Septet<A,​B,​C,​X0,​X1,​D,​E>
      addAt3​(Pair<X0,​X1> tuple)  
      <X0,​X1,​X2,​X3>
      Ennead<A,​B,​C,​X0,​X1,​X2,​X3,​D,​E>
      addAt3​(Quartet<X0,​X1,​X2,​X3> tuple)  
      <X0,​X1,​X2,​X3,​X4>
      Decade<A,​B,​C,​X0,​X1,​X2,​X3,​X4,​D,​E>
      addAt3​(Quintet<X0,​X1,​X2,​X3,​X4> tuple)  
      <X0,​X1,​X2>
      Octet<A,​B,​C,​X0,​X1,​X2,​D,​E>
      addAt3​(Triplet<X0,​X1,​X2> tuple)  
      <X0> Sextet<A,​B,​C,​X0,​D,​E> addAt3​(Unit<X0> tuple)  
      <X0> Sextet<A,​B,​C,​X0,​D,​E> addAt3​(X0 value0)  
      <X0,​X1>
      Septet<A,​B,​C,​X0,​X1,​D,​E>
      addAt3​(X0 value0, X1 value1)  
      <X0,​X1,​X2>
      Octet<A,​B,​C,​X0,​X1,​X2,​D,​E>
      addAt3​(X0 value0, X1 value1, X2 value2)  
      <X0,​X1,​X2,​X3>
      Ennead<A,​B,​C,​X0,​X1,​X2,​X3,​D,​E>
      addAt3​(X0 value0, X1 value1, X2 value2, X3 value3)  
      <X0,​X1,​X2,​X3,​X4>
      Decade<A,​B,​C,​X0,​X1,​X2,​X3,​X4,​D,​E>
      addAt3​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4)  
      <X0,​X1>
      Septet<A,​B,​C,​D,​X0,​X1,​E>
      addAt4​(Pair<X0,​X1> tuple)  
      <X0,​X1,​X2,​X3>
      Ennead<A,​B,​C,​D,​X0,​X1,​X2,​X3,​E>
      addAt4​(Quartet<X0,​X1,​X2,​X3> tuple)  
      <X0,​X1,​X2,​X3,​X4>
      Decade<A,​B,​C,​D,​X0,​X1,​X2,​X3,​X4,​E>
      addAt4​(Quintet<X0,​X1,​X2,​X3,​X4> tuple)  
      <X0,​X1,​X2>
      Octet<A,​B,​C,​D,​X0,​X1,​X2,​E>
      addAt4​(Triplet<X0,​X1,​X2> tuple)  
      <X0> Sextet<A,​B,​C,​D,​X0,​E> addAt4​(Unit<X0> tuple)  
      <X0> Sextet<A,​B,​C,​D,​X0,​E> addAt4​(X0 value0)  
      <X0,​X1>
      Septet<A,​B,​C,​D,​X0,​X1,​E>
      addAt4​(X0 value0, X1 value1)  
      <X0,​X1,​X2>
      Octet<A,​B,​C,​D,​X0,​X1,​X2,​E>
      addAt4​(X0 value0, X1 value1, X2 value2)  
      <X0,​X1,​X2,​X3>
      Ennead<A,​B,​C,​D,​X0,​X1,​X2,​X3,​E>
      addAt4​(X0 value0, X1 value1, X2 value2, X3 value3)  
      <X0,​X1,​X2,​X3,​X4>
      Decade<A,​B,​C,​D,​X0,​X1,​X2,​X3,​X4,​E>
      addAt4​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4)  
      <X0,​X1>
      Septet<A,​B,​C,​D,​E,​X0,​X1>
      addAt5​(Pair<X0,​X1> tuple)  
      <X0,​X1,​X2,​X3>
      Ennead<A,​B,​C,​D,​E,​X0,​X1,​X2,​X3>
      addAt5​(Quartet<X0,​X1,​X2,​X3> tuple)  
      <X0,​X1,​X2,​X3,​X4>
      Decade<A,​B,​C,​D,​E,​X0,​X1,​X2,​X3,​X4>
      addAt5​(Quintet<X0,​X1,​X2,​X3,​X4> tuple)  
      <X0,​X1,​X2>
      Octet<A,​B,​C,​D,​E,​X0,​X1,​X2>
      addAt5​(Triplet<X0,​X1,​X2> tuple)  
      <X0> Sextet<A,​B,​C,​D,​E,​X0> addAt5​(Unit<X0> tuple)  
      <X0> Sextet<A,​B,​C,​D,​E,​X0> addAt5​(X0 value0)  
      <X0,​X1>
      Septet<A,​B,​C,​D,​E,​X0,​X1>
      addAt5​(X0 value0, X1 value1)  
      <X0,​X1,​X2>
      Octet<A,​B,​C,​D,​E,​X0,​X1,​X2>
      addAt5​(X0 value0, X1 value1, X2 value2)  
      <X0,​X1,​X2,​X3>
      Ennead<A,​B,​C,​D,​E,​X0,​X1,​X2,​X3>
      addAt5​(X0 value0, X1 value1, X2 value2, X3 value3)  
      <X0,​X1,​X2,​X3,​X4>
      Decade<A,​B,​C,​D,​E,​X0,​X1,​X2,​X3,​X4>
      addAt5​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4)  
      static <X> Quintet<X,​X,​X,​X,​X> fromArray​(X[] array)
      Create tuple from array.
      static <X> Quintet<X,​X,​X,​X,​X> fromCollection​(java.util.Collection<X> collection)
      Create tuple from collection.
      static <X> Quintet<X,​X,​X,​X,​X> fromIterable​(java.lang.Iterable<X> iterable)
      Create tuple from iterable.
      static <X> Quintet<X,​X,​X,​X,​X> fromIterable​(java.lang.Iterable<X> iterable, int index)
      Create tuple from iterable, starting from the specified index.
      private static <X> Quintet<X,​X,​X,​X,​X> fromIterable​(java.lang.Iterable<X> iterable, int index, boolean exactSize)  
      int getSize()
      Return the size of the tuple.
      A getValue0()  
      B getValue1()  
      C getValue2()  
      D getValue3()  
      E getValue4()  
      Quartet<B,​C,​D,​E> removeFrom0()  
      Quartet<A,​C,​D,​E> removeFrom1()  
      Quartet<A,​B,​D,​E> removeFrom2()  
      Quartet<A,​B,​C,​E> removeFrom3()  
      Quartet<A,​B,​C,​D> removeFrom4()  
      <X> Quintet<X,​B,​C,​D,​E> setAt0​(X value)  
      <X> Quintet<A,​X,​C,​D,​E> setAt1​(X value)  
      <X> Quintet<A,​B,​X,​D,​E> setAt2​(X value)  
      <X> Quintet<A,​B,​C,​X,​E> setAt3​(X value)  
      <X> Quintet<A,​B,​C,​D,​X> setAt4​(X value)  
      static <A,​B,​C,​D,​E>
      Quintet<A,​B,​C,​D,​E>
      with​(A value0, B value1, C value2, D value3, E value4)  
      • Methods inherited from class java.lang.Object

        clone, finalize, getClass, notify, notifyAll, wait, wait, wait
      • Methods inherited from interface java.lang.Iterable

        forEach, spliterator
    • Field Detail

      • val0

        private final A val0
      • val1

        private final B val1
      • val2

        private final C val2
      • val3

        private final D val3
      • val4

        private final E val4
    • Constructor Detail

      • Quintet

        public Quintet​(A value0,
                       B value1,
                       C value2,
                       D value3,
                       E value4)
    • Method Detail

      • with

        public static <A,​B,​C,​D,​E> Quintet<A,​B,​C,​D,​E> with​(A value0,
                                                                                                          B value1,
                                                                                                          C value2,
                                                                                                          D value3,
                                                                                                          E value4)
      • fromArray

        public static <X> Quintet<X,​X,​X,​X,​X> fromArray​(X[] array)

        Create tuple from array. Array has to have exactly five elements.

        Type Parameters:
        X - the array component type
        Parameters:
        array - the array to be converted to a tuple
        Returns:
        the tuple
      • fromCollection

        public static <X> Quintet<X,​X,​X,​X,​X> fromCollection​(java.util.Collection<X> collection)

        Create tuple from collection. Collection has to have exactly five elements.

        Type Parameters:
        X - the collection component type
        Parameters:
        collection - the collection to be converted to a tuple
        Returns:
        the tuple
      • fromIterable

        public static <X> Quintet<X,​X,​X,​X,​X> fromIterable​(java.lang.Iterable<X> iterable)

        Create tuple from iterable. Iterable has to have exactly five elements.

        Type Parameters:
        X - the iterable component type
        Parameters:
        iterable - the iterable to be converted to a tuple
        Returns:
        the tuple
      • fromIterable

        public static <X> Quintet<X,​X,​X,​X,​X> fromIterable​(java.lang.Iterable<X> iterable,
                                                                                  int index)

        Create tuple from iterable, starting from the specified index. Iterable can have more (or less) elements than the tuple to be created.

        Type Parameters:
        X - the iterable component type
        Parameters:
        iterable - the iterable to be converted to a tuple
        Returns:
        the tuple
      • fromIterable

        private static <X> Quintet<X,​X,​X,​X,​X> fromIterable​(java.lang.Iterable<X> iterable,
                                                                                   int index,
                                                                                   boolean exactSize)
      • getSize

        public int getSize()
        Description copied from class: Tuple

        Return the size of the tuple.

        Specified by:
        getSize in class Tuple
        Returns:
        the size of the tuple.
      • addAt0

        public <X0> Sextet<X0,​A,​B,​C,​D,​E> addAt0​(X0 value0)
      • addAt1

        public <X0> Sextet<A,​X0,​B,​C,​D,​E> addAt1​(X0 value0)
      • addAt2

        public <X0> Sextet<A,​B,​X0,​C,​D,​E> addAt2​(X0 value0)
      • addAt3

        public <X0> Sextet<A,​B,​C,​X0,​D,​E> addAt3​(X0 value0)
      • addAt4

        public <X0> Sextet<A,​B,​C,​D,​X0,​E> addAt4​(X0 value0)
      • addAt5

        public <X0> Sextet<A,​B,​C,​D,​E,​X0> addAt5​(X0 value0)
      • addAt0

        public <X0,​X1> Septet<X0,​X1,​A,​B,​C,​D,​E> addAt0​(X0 value0,
                                                                                                X1 value1)
      • addAt1

        public <X0,​X1> Septet<A,​X0,​X1,​B,​C,​D,​E> addAt1​(X0 value0,
                                                                                                X1 value1)
      • addAt2

        public <X0,​X1> Septet<A,​B,​X0,​X1,​C,​D,​E> addAt2​(X0 value0,
                                                                                                X1 value1)
      • addAt3

        public <X0,​X1> Septet<A,​B,​C,​X0,​X1,​D,​E> addAt3​(X0 value0,
                                                                                                X1 value1)
      • addAt4

        public <X0,​X1> Septet<A,​B,​C,​D,​X0,​X1,​E> addAt4​(X0 value0,
                                                                                                X1 value1)
      • addAt5

        public <X0,​X1> Septet<A,​B,​C,​D,​E,​X0,​X1> addAt5​(X0 value0,
                                                                                                X1 value1)
      • addAt0

        public <X0,​X1,​X2> Octet<X0,​X1,​X2,​A,​B,​C,​D,​E> addAt0​(X0 value0,
                                                                                                                 X1 value1,
                                                                                                                 X2 value2)
      • addAt1

        public <X0,​X1,​X2> Octet<A,​X0,​X1,​X2,​B,​C,​D,​E> addAt1​(X0 value0,
                                                                                                                 X1 value1,
                                                                                                                 X2 value2)
      • addAt2

        public <X0,​X1,​X2> Octet<A,​B,​X0,​X1,​X2,​C,​D,​E> addAt2​(X0 value0,
                                                                                                                 X1 value1,
                                                                                                                 X2 value2)
      • addAt3

        public <X0,​X1,​X2> Octet<A,​B,​C,​X0,​X1,​X2,​D,​E> addAt3​(X0 value0,
                                                                                                                 X1 value1,
                                                                                                                 X2 value2)
      • addAt4

        public <X0,​X1,​X2> Octet<A,​B,​C,​D,​X0,​X1,​X2,​E> addAt4​(X0 value0,
                                                                                                                 X1 value1,
                                                                                                                 X2 value2)
      • addAt5

        public <X0,​X1,​X2> Octet<A,​B,​C,​D,​E,​X0,​X1,​X2> addAt5​(X0 value0,
                                                                                                                 X1 value1,
                                                                                                                 X2 value2)
      • addAt0

        public <X0,​X1,​X2,​X3> Ennead<X0,​X1,​X2,​X3,​A,​B,​C,​D,​E> addAt0​(X0 value0,
                                                                                                                                    X1 value1,
                                                                                                                                    X2 value2,
                                                                                                                                    X3 value3)
      • addAt1

        public <X0,​X1,​X2,​X3> Ennead<A,​X0,​X1,​X2,​X3,​B,​C,​D,​E> addAt1​(X0 value0,
                                                                                                                                    X1 value1,
                                                                                                                                    X2 value2,
                                                                                                                                    X3 value3)
      • addAt2

        public <X0,​X1,​X2,​X3> Ennead<A,​B,​X0,​X1,​X2,​X3,​C,​D,​E> addAt2​(X0 value0,
                                                                                                                                    X1 value1,
                                                                                                                                    X2 value2,
                                                                                                                                    X3 value3)
      • addAt3

        public <X0,​X1,​X2,​X3> Ennead<A,​B,​C,​X0,​X1,​X2,​X3,​D,​E> addAt3​(X0 value0,
                                                                                                                                    X1 value1,
                                                                                                                                    X2 value2,
                                                                                                                                    X3 value3)
      • addAt4

        public <X0,​X1,​X2,​X3> Ennead<A,​B,​C,​D,​X0,​X1,​X2,​X3,​E> addAt4​(X0 value0,
                                                                                                                                    X1 value1,
                                                                                                                                    X2 value2,
                                                                                                                                    X3 value3)
      • addAt5

        public <X0,​X1,​X2,​X3> Ennead<A,​B,​C,​D,​E,​X0,​X1,​X2,​X3> addAt5​(X0 value0,
                                                                                                                                    X1 value1,
                                                                                                                                    X2 value2,
                                                                                                                                    X3 value3)
      • addAt0

        public <X0,​X1,​X2,​X3,​X4> Decade<X0,​X1,​X2,​X3,​X4,​A,​B,​C,​D,​E> addAt0​(X0 value0,
                                                                                                                                                      X1 value1,
                                                                                                                                                      X2 value2,
                                                                                                                                                      X3 value3,
                                                                                                                                                      X4 value4)
      • addAt1

        public <X0,​X1,​X2,​X3,​X4> Decade<A,​X0,​X1,​X2,​X3,​X4,​B,​C,​D,​E> addAt1​(X0 value0,
                                                                                                                                                      X1 value1,
                                                                                                                                                      X2 value2,
                                                                                                                                                      X3 value3,
                                                                                                                                                      X4 value4)
      • addAt2

        public <X0,​X1,​X2,​X3,​X4> Decade<A,​B,​X0,​X1,​X2,​X3,​X4,​C,​D,​E> addAt2​(X0 value0,
                                                                                                                                                      X1 value1,
                                                                                                                                                      X2 value2,
                                                                                                                                                      X3 value3,
                                                                                                                                                      X4 value4)
      • addAt3

        public <X0,​X1,​X2,​X3,​X4> Decade<A,​B,​C,​X0,​X1,​X2,​X3,​X4,​D,​E> addAt3​(X0 value0,
                                                                                                                                                      X1 value1,
                                                                                                                                                      X2 value2,
                                                                                                                                                      X3 value3,
                                                                                                                                                      X4 value4)
      • addAt4

        public <X0,​X1,​X2,​X3,​X4> Decade<A,​B,​C,​D,​X0,​X1,​X2,​X3,​X4,​E> addAt4​(X0 value0,
                                                                                                                                                      X1 value1,
                                                                                                                                                      X2 value2,
                                                                                                                                                      X3 value3,
                                                                                                                                                      X4 value4)
      • addAt5

        public <X0,​X1,​X2,​X3,​X4> Decade<A,​B,​C,​D,​E,​X0,​X1,​X2,​X3,​X4> addAt5​(X0 value0,
                                                                                                                                                      X1 value1,
                                                                                                                                                      X2 value2,
                                                                                                                                                      X3 value3,
                                                                                                                                                      X4 value4)
      • addAt0

        public <X0> Sextet<X0,​A,​B,​C,​D,​E> addAt0​(Unit<X0> tuple)
      • addAt1

        public <X0> Sextet<A,​X0,​B,​C,​D,​E> addAt1​(Unit<X0> tuple)
      • addAt2

        public <X0> Sextet<A,​B,​X0,​C,​D,​E> addAt2​(Unit<X0> tuple)
      • addAt3

        public <X0> Sextet<A,​B,​C,​X0,​D,​E> addAt3​(Unit<X0> tuple)
      • addAt4

        public <X0> Sextet<A,​B,​C,​D,​X0,​E> addAt4​(Unit<X0> tuple)
      • addAt5

        public <X0> Sextet<A,​B,​C,​D,​E,​X0> addAt5​(Unit<X0> tuple)
      • addAt0

        public <X0,​X1> Septet<X0,​X1,​A,​B,​C,​D,​E> addAt0​(Pair<X0,​X1> tuple)
      • addAt1

        public <X0,​X1> Septet<A,​X0,​X1,​B,​C,​D,​E> addAt1​(Pair<X0,​X1> tuple)
      • addAt2

        public <X0,​X1> Septet<A,​B,​X0,​X1,​C,​D,​E> addAt2​(Pair<X0,​X1> tuple)
      • addAt3

        public <X0,​X1> Septet<A,​B,​C,​X0,​X1,​D,​E> addAt3​(Pair<X0,​X1> tuple)
      • addAt4

        public <X0,​X1> Septet<A,​B,​C,​D,​X0,​X1,​E> addAt4​(Pair<X0,​X1> tuple)
      • addAt5

        public <X0,​X1> Septet<A,​B,​C,​D,​E,​X0,​X1> addAt5​(Pair<X0,​X1> tuple)
      • addAt0

        public <X0,​X1,​X2> Octet<X0,​X1,​X2,​A,​B,​C,​D,​E> addAt0​(Triplet<X0,​X1,​X2> tuple)
      • addAt1

        public <X0,​X1,​X2> Octet<A,​X0,​X1,​X2,​B,​C,​D,​E> addAt1​(Triplet<X0,​X1,​X2> tuple)
      • addAt2

        public <X0,​X1,​X2> Octet<A,​B,​X0,​X1,​X2,​C,​D,​E> addAt2​(Triplet<X0,​X1,​X2> tuple)
      • addAt3

        public <X0,​X1,​X2> Octet<A,​B,​C,​X0,​X1,​X2,​D,​E> addAt3​(Triplet<X0,​X1,​X2> tuple)
      • addAt4

        public <X0,​X1,​X2> Octet<A,​B,​C,​D,​X0,​X1,​X2,​E> addAt4​(Triplet<X0,​X1,​X2> tuple)
      • addAt5

        public <X0,​X1,​X2> Octet<A,​B,​C,​D,​E,​X0,​X1,​X2> addAt5​(Triplet<X0,​X1,​X2> tuple)
      • addAt0

        public <X0,​X1,​X2,​X3> Ennead<X0,​X1,​X2,​X3,​A,​B,​C,​D,​E> addAt0​(Quartet<X0,​X1,​X2,​X3> tuple)
      • addAt1

        public <X0,​X1,​X2,​X3> Ennead<A,​X0,​X1,​X2,​X3,​B,​C,​D,​E> addAt1​(Quartet<X0,​X1,​X2,​X3> tuple)
      • addAt2

        public <X0,​X1,​X2,​X3> Ennead<A,​B,​X0,​X1,​X2,​X3,​C,​D,​E> addAt2​(Quartet<X0,​X1,​X2,​X3> tuple)
      • addAt3

        public <X0,​X1,​X2,​X3> Ennead<A,​B,​C,​X0,​X1,​X2,​X3,​D,​E> addAt3​(Quartet<X0,​X1,​X2,​X3> tuple)
      • addAt4

        public <X0,​X1,​X2,​X3> Ennead<A,​B,​C,​D,​X0,​X1,​X2,​X3,​E> addAt4​(Quartet<X0,​X1,​X2,​X3> tuple)
      • addAt5

        public <X0,​X1,​X2,​X3> Ennead<A,​B,​C,​D,​E,​X0,​X1,​X2,​X3> addAt5​(Quartet<X0,​X1,​X2,​X3> tuple)
      • addAt0

        public <X0,​X1,​X2,​X3,​X4> Decade<X0,​X1,​X2,​X3,​X4,​A,​B,​C,​D,​E> addAt0​(Quintet<X0,​X1,​X2,​X3,​X4> tuple)
      • addAt1

        public <X0,​X1,​X2,​X3,​X4> Decade<A,​X0,​X1,​X2,​X3,​X4,​B,​C,​D,​E> addAt1​(Quintet<X0,​X1,​X2,​X3,​X4> tuple)
      • addAt2

        public <X0,​X1,​X2,​X3,​X4> Decade<A,​B,​X0,​X1,​X2,​X3,​X4,​C,​D,​E> addAt2​(Quintet<X0,​X1,​X2,​X3,​X4> tuple)
      • addAt3

        public <X0,​X1,​X2,​X3,​X4> Decade<A,​B,​C,​X0,​X1,​X2,​X3,​X4,​D,​E> addAt3​(Quintet<X0,​X1,​X2,​X3,​X4> tuple)
      • addAt4

        public <X0,​X1,​X2,​X3,​X4> Decade<A,​B,​C,​D,​X0,​X1,​X2,​X3,​X4,​E> addAt4​(Quintet<X0,​X1,​X2,​X3,​X4> tuple)
      • addAt5

        public <X0,​X1,​X2,​X3,​X4> Decade<A,​B,​C,​D,​E,​X0,​X1,​X2,​X3,​X4> addAt5​(Quintet<X0,​X1,​X2,​X3,​X4> tuple)
      • add

        public <X0> Sextet<A,​B,​C,​D,​E,​X0> add​(X0 value0)
      • add

        public <X0> Sextet<A,​B,​C,​D,​E,​X0> add​(Unit<X0> tuple)
      • add

        public <X0,​X1> Septet<A,​B,​C,​D,​E,​X0,​X1> add​(X0 value0,
                                                                                             X1 value1)
      • add

        public <X0,​X1> Septet<A,​B,​C,​D,​E,​X0,​X1> add​(Pair<X0,​X1> tuple)
      • add

        public <X0,​X1,​X2> Octet<A,​B,​C,​D,​E,​X0,​X1,​X2> add​(X0 value0,
                                                                                                              X1 value1,
                                                                                                              X2 value2)
      • add

        public <X0,​X1,​X2> Octet<A,​B,​C,​D,​E,​X0,​X1,​X2> add​(Triplet<X0,​X1,​X2> tuple)
      • add

        public <X0,​X1,​X2,​X3> Ennead<A,​B,​C,​D,​E,​X0,​X1,​X2,​X3> add​(X0 value0,
                                                                                                                                 X1 value1,
                                                                                                                                 X2 value2,
                                                                                                                                 X3 value3)
      • add

        public <X0,​X1,​X2,​X3> Ennead<A,​B,​C,​D,​E,​X0,​X1,​X2,​X3> add​(Quartet<X0,​X1,​X2,​X3> tuple)
      • add

        public <X0,​X1,​X2,​X3,​X4> Decade<A,​B,​C,​D,​E,​X0,​X1,​X2,​X3,​X4> add​(X0 value0,
                                                                                                                                                   X1 value1,
                                                                                                                                                   X2 value2,
                                                                                                                                                   X3 value3,
                                                                                                                                                   X4 value4)
      • add

        public <X0,​X1,​X2,​X3,​X4> Decade<A,​B,​C,​D,​E,​X0,​X1,​X2,​X3,​X4> add​(Quintet<X0,​X1,​X2,​X3,​X4> tuple)
      • setAt0

        public <X> Quintet<X,​B,​C,​D,​E> setAt0​(X value)
      • setAt1

        public <X> Quintet<A,​X,​C,​D,​E> setAt1​(X value)
      • setAt2

        public <X> Quintet<A,​B,​X,​D,​E> setAt2​(X value)
      • setAt3

        public <X> Quintet<A,​B,​C,​X,​E> setAt3​(X value)
      • setAt4

        public <X> Quintet<A,​B,​C,​D,​X> setAt4​(X value)
      • removeFrom0

        public Quartet<B,​C,​D,​E> removeFrom0()
      • removeFrom1

        public Quartet<A,​C,​D,​E> removeFrom1()
      • removeFrom2

        public Quartet<A,​B,​D,​E> removeFrom2()
      • removeFrom3

        public Quartet<A,​B,​C,​E> removeFrom3()
      • removeFrom4

        public Quartet<A,​B,​C,​D> removeFrom4()