Class Unit<A>

  • All Implemented Interfaces:
    java.io.Serializable, java.lang.Comparable<Tuple>, java.lang.Iterable<java.lang.Object>, IValue0<A>

    public final class Unit<A>
    extends Tuple
    implements IValue0<A>

    A tuple of one element.

    Since:
    1.0
    See Also:
    Serialized Form
    • Field Summary

      Fields 
      Modifier and Type Field Description
      private static long serialVersionUID  
      private static int SIZE  
      private A val0  
    • Constructor Summary

      Constructors 
      Constructor Description
      Unit​(A value0)  
    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8>
      Decade<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8>
      add​(Ennead<X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8> tuple)  
      <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7>
      Ennead<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7>
      add​(Octet<X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7> tuple)  
      <X0,​X1>
      Triplet<A,​X0,​X1>
      add​(Pair<X0,​X1> tuple)  
      <X0,​X1,​X2,​X3>
      Quintet<A,​X0,​X1,​X2,​X3>
      add​(Quartet<X0,​X1,​X2,​X3> tuple)  
      <X0,​X1,​X2,​X3,​X4>
      Sextet<A,​X0,​X1,​X2,​X3,​X4>
      add​(Quintet<X0,​X1,​X2,​X3,​X4> tuple)  
      <X0,​X1,​X2,​X3,​X4,​X5,​X6>
      Octet<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6>
      add​(Septet<X0,​X1,​X2,​X3,​X4,​X5,​X6> tuple)  
      <X0,​X1,​X2,​X3,​X4,​X5>
      Septet<A,​X0,​X1,​X2,​X3,​X4,​X5>
      add​(Sextet<X0,​X1,​X2,​X3,​X4,​X5> tuple)  
      <X0,​X1,​X2>
      Quartet<A,​X0,​X1,​X2>
      add​(Triplet<X0,​X1,​X2> tuple)  
      <X0> Pair<A,​X0> add​(Unit<X0> tuple)  
      <X0> Pair<A,​X0> add​(X0 value0)  
      <X0,​X1>
      Triplet<A,​X0,​X1>
      add​(X0 value0, X1 value1)  
      <X0,​X1,​X2>
      Quartet<A,​X0,​X1,​X2>
      add​(X0 value0, X1 value1, X2 value2)  
      <X0,​X1,​X2,​X3>
      Quintet<A,​X0,​X1,​X2,​X3>
      add​(X0 value0, X1 value1, X2 value2, X3 value3)  
      <X0,​X1,​X2,​X3,​X4>
      Sextet<A,​X0,​X1,​X2,​X3,​X4>
      add​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4)  
      <X0,​X1,​X2,​X3,​X4,​X5>
      Septet<A,​X0,​X1,​X2,​X3,​X4,​X5>
      add​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5)  
      <X0,​X1,​X2,​X3,​X4,​X5,​X6>
      Octet<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6>
      add​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6)  
      <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7>
      Ennead<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7>
      add​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6, X7 value7)  
      <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8>
      Decade<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8>
      add​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6, X7 value7, X8 value8)  
      <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8>
      Decade<X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8,​A>
      addAt0​(Ennead<X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8> tuple)  
      <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7>
      Ennead<X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​A>
      addAt0​(Octet<X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7> tuple)  
      <X0,​X1>
      Triplet<X0,​X1,​A>
      addAt0​(Pair<X0,​X1> tuple)  
      <X0,​X1,​X2,​X3>
      Quintet<X0,​X1,​X2,​X3,​A>
      addAt0​(Quartet<X0,​X1,​X2,​X3> tuple)  
      <X0,​X1,​X2,​X3,​X4>
      Sextet<X0,​X1,​X2,​X3,​X4,​A>
      addAt0​(Quintet<X0,​X1,​X2,​X3,​X4> tuple)  
      <X0,​X1,​X2,​X3,​X4,​X5,​X6>
      Octet<X0,​X1,​X2,​X3,​X4,​X5,​X6,​A>
      addAt0​(Septet<X0,​X1,​X2,​X3,​X4,​X5,​X6> tuple)  
      <X0,​X1,​X2,​X3,​X4,​X5>
      Septet<X0,​X1,​X2,​X3,​X4,​X5,​A>
      addAt0​(Sextet<X0,​X1,​X2,​X3,​X4,​X5> tuple)  
      <X0,​X1,​X2>
      Quartet<X0,​X1,​X2,​A>
      addAt0​(Triplet<X0,​X1,​X2> tuple)  
      <X0> Pair<X0,​A> addAt0​(Unit<X0> tuple)  
      <X0> Pair<X0,​A> addAt0​(X0 value0)  
      <X0,​X1>
      Triplet<X0,​X1,​A>
      addAt0​(X0 value0, X1 value1)  
      <X0,​X1,​X2>
      Quartet<X0,​X1,​X2,​A>
      addAt0​(X0 value0, X1 value1, X2 value2)  
      <X0,​X1,​X2,​X3>
      Quintet<X0,​X1,​X2,​X3,​A>
      addAt0​(X0 value0, X1 value1, X2 value2, X3 value3)  
      <X0,​X1,​X2,​X3,​X4>
      Sextet<X0,​X1,​X2,​X3,​X4,​A>
      addAt0​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4)  
      <X0,​X1,​X2,​X3,​X4,​X5>
      Septet<X0,​X1,​X2,​X3,​X4,​X5,​A>
      addAt0​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5)  
      <X0,​X1,​X2,​X3,​X4,​X5,​X6>
      Octet<X0,​X1,​X2,​X3,​X4,​X5,​X6,​A>
      addAt0​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6)  
      <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7>
      Ennead<X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​A>
      addAt0​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6, X7 value7)  
      <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8>
      Decade<X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8,​A>
      addAt0​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6, X7 value7, X8 value8)  
      <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8>
      Decade<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8>
      addAt1​(Ennead<X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8> tuple)  
      <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7>
      Ennead<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7>
      addAt1​(Octet<X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7> tuple)  
      <X0,​X1>
      Triplet<A,​X0,​X1>
      addAt1​(Pair<X0,​X1> tuple)  
      <X0,​X1,​X2,​X3>
      Quintet<A,​X0,​X1,​X2,​X3>
      addAt1​(Quartet<X0,​X1,​X2,​X3> tuple)  
      <X0,​X1,​X2,​X3,​X4>
      Sextet<A,​X0,​X1,​X2,​X3,​X4>
      addAt1​(Quintet<X0,​X1,​X2,​X3,​X4> tuple)  
      <X0,​X1,​X2,​X3,​X4,​X5,​X6>
      Octet<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6>
      addAt1​(Septet<X0,​X1,​X2,​X3,​X4,​X5,​X6> tuple)  
      <X0,​X1,​X2,​X3,​X4,​X5>
      Septet<A,​X0,​X1,​X2,​X3,​X4,​X5>
      addAt1​(Sextet<X0,​X1,​X2,​X3,​X4,​X5> tuple)  
      <X0,​X1,​X2>
      Quartet<A,​X0,​X1,​X2>
      addAt1​(Triplet<X0,​X1,​X2> tuple)  
      <X0> Pair<A,​X0> addAt1​(Unit<X0> tuple)  
      <X0> Pair<A,​X0> addAt1​(X0 value0)  
      <X0,​X1>
      Triplet<A,​X0,​X1>
      addAt1​(X0 value0, X1 value1)  
      <X0,​X1,​X2>
      Quartet<A,​X0,​X1,​X2>
      addAt1​(X0 value0, X1 value1, X2 value2)  
      <X0,​X1,​X2,​X3>
      Quintet<A,​X0,​X1,​X2,​X3>
      addAt1​(X0 value0, X1 value1, X2 value2, X3 value3)  
      <X0,​X1,​X2,​X3,​X4>
      Sextet<A,​X0,​X1,​X2,​X3,​X4>
      addAt1​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4)  
      <X0,​X1,​X2,​X3,​X4,​X5>
      Septet<A,​X0,​X1,​X2,​X3,​X4,​X5>
      addAt1​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5)  
      <X0,​X1,​X2,​X3,​X4,​X5,​X6>
      Octet<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6>
      addAt1​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6)  
      <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7>
      Ennead<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7>
      addAt1​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6, X7 value7)  
      <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8>
      Decade<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8>
      addAt1​(X0 value0, X1 value1, X2 value2, X3 value3, X4 value4, X5 value5, X6 value6, X7 value7, X8 value8)  
      static <X> Unit<X> fromArray​(X[] array)
      Create tuple from array.
      static <X> Unit<X> fromCollection​(java.util.Collection<X> collection)
      Create tuple from collection.
      static <X> Unit<X> fromIterable​(java.lang.Iterable<X> iterable)
      Create tuple from iterable.
      static <X> Unit<X> fromIterable​(java.lang.Iterable<X> iterable, int index)
      Create tuple from iterable, starting from the specified index.
      private static <X> Unit<X> fromIterable​(java.lang.Iterable<X> iterable, int index, boolean exactSize)  
      int getSize()
      Return the size of the tuple.
      A getValue0()  
      <X> Unit<X> setAt0​(X value)  
      static <A> Unit<A> with​(A value0)  
      • Methods inherited from class java.lang.Object

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

        forEach, spliterator
    • Constructor Detail

      • Unit

        public Unit​(A value0)
    • Method Detail

      • with

        public static <A> Unit<A> with​(A value0)
      • fromArray

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

        Create tuple from array. Array has to have exactly one element.

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

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

        Create tuple from collection. Collection has to have exactly one element.

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

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

        Create tuple from iterable. Iterable has to have exactly one element.

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

        public static <X> Unit<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> Unit<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> Pair<X0,​A> addAt0​(X0 value0)
      • addAt1

        public <X0> Pair<A,​X0> addAt1​(X0 value0)
      • addAt0

        public <X0,​X1> Triplet<X0,​X1,​A> addAt0​(X0 value0,
                                                                 X1 value1)
      • addAt1

        public <X0,​X1> Triplet<A,​X0,​X1> addAt1​(X0 value0,
                                                                 X1 value1)
      • addAt0

        public <X0,​X1,​X2> Quartet<X0,​X1,​X2,​A> addAt0​(X0 value0,
                                                                                   X1 value1,
                                                                                   X2 value2)
      • addAt1

        public <X0,​X1,​X2> Quartet<A,​X0,​X1,​X2> addAt1​(X0 value0,
                                                                                   X1 value1,
                                                                                   X2 value2)
      • addAt0

        public <X0,​X1,​X2,​X3> Quintet<X0,​X1,​X2,​X3,​A> addAt0​(X0 value0,
                                                                                                     X1 value1,
                                                                                                     X2 value2,
                                                                                                     X3 value3)
      • addAt1

        public <X0,​X1,​X2,​X3> Quintet<A,​X0,​X1,​X2,​X3> addAt1​(X0 value0,
                                                                                                     X1 value1,
                                                                                                     X2 value2,
                                                                                                     X3 value3)
      • addAt0

        public <X0,​X1,​X2,​X3,​X4> Sextet<X0,​X1,​X2,​X3,​X4,​A> addAt0​(X0 value0,
                                                                                                                      X1 value1,
                                                                                                                      X2 value2,
                                                                                                                      X3 value3,
                                                                                                                      X4 value4)
      • addAt1

        public <X0,​X1,​X2,​X3,​X4> Sextet<A,​X0,​X1,​X2,​X3,​X4> addAt1​(X0 value0,
                                                                                                                      X1 value1,
                                                                                                                      X2 value2,
                                                                                                                      X3 value3,
                                                                                                                      X4 value4)
      • addAt0

        public <X0,​X1,​X2,​X3,​X4,​X5> Septet<X0,​X1,​X2,​X3,​X4,​X5,​A> addAt0​(X0 value0,
                                                                                                                                        X1 value1,
                                                                                                                                        X2 value2,
                                                                                                                                        X3 value3,
                                                                                                                                        X4 value4,
                                                                                                                                        X5 value5)
      • addAt1

        public <X0,​X1,​X2,​X3,​X4,​X5> Septet<A,​X0,​X1,​X2,​X3,​X4,​X5> addAt1​(X0 value0,
                                                                                                                                        X1 value1,
                                                                                                                                        X2 value2,
                                                                                                                                        X3 value3,
                                                                                                                                        X4 value4,
                                                                                                                                        X5 value5)
      • addAt0

        public <X0,​X1,​X2,​X3,​X4,​X5,​X6> Octet<X0,​X1,​X2,​X3,​X4,​X5,​X6,​A> addAt0​(X0 value0,
                                                                                                                                                         X1 value1,
                                                                                                                                                         X2 value2,
                                                                                                                                                         X3 value3,
                                                                                                                                                         X4 value4,
                                                                                                                                                         X5 value5,
                                                                                                                                                         X6 value6)
      • addAt1

        public <X0,​X1,​X2,​X3,​X4,​X5,​X6> Octet<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6> addAt1​(X0 value0,
                                                                                                                                                         X1 value1,
                                                                                                                                                         X2 value2,
                                                                                                                                                         X3 value3,
                                                                                                                                                         X4 value4,
                                                                                                                                                         X5 value5,
                                                                                                                                                         X6 value6)
      • addAt0

        public <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7> Ennead<X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​A> addAt0​(X0 value0,
                                                                                                                                                                            X1 value1,
                                                                                                                                                                            X2 value2,
                                                                                                                                                                            X3 value3,
                                                                                                                                                                            X4 value4,
                                                                                                                                                                            X5 value5,
                                                                                                                                                                            X6 value6,
                                                                                                                                                                            X7 value7)
      • addAt1

        public <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7> Ennead<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7> addAt1​(X0 value0,
                                                                                                                                                                            X1 value1,
                                                                                                                                                                            X2 value2,
                                                                                                                                                                            X3 value3,
                                                                                                                                                                            X4 value4,
                                                                                                                                                                            X5 value5,
                                                                                                                                                                            X6 value6,
                                                                                                                                                                            X7 value7)
      • addAt0

        public <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8> Decade<X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8,​A> addAt0​(X0 value0,
                                                                                                                                                                                              X1 value1,
                                                                                                                                                                                              X2 value2,
                                                                                                                                                                                              X3 value3,
                                                                                                                                                                                              X4 value4,
                                                                                                                                                                                              X5 value5,
                                                                                                                                                                                              X6 value6,
                                                                                                                                                                                              X7 value7,
                                                                                                                                                                                              X8 value8)
      • addAt1

        public <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8> Decade<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8> addAt1​(X0 value0,
                                                                                                                                                                                              X1 value1,
                                                                                                                                                                                              X2 value2,
                                                                                                                                                                                              X3 value3,
                                                                                                                                                                                              X4 value4,
                                                                                                                                                                                              X5 value5,
                                                                                                                                                                                              X6 value6,
                                                                                                                                                                                              X7 value7,
                                                                                                                                                                                              X8 value8)
      • addAt0

        public <X0> Pair<X0,​A> addAt0​(Unit<X0> tuple)
      • addAt1

        public <X0> Pair<A,​X0> addAt1​(Unit<X0> tuple)
      • addAt0

        public <X0,​X1> Triplet<X0,​X1,​A> addAt0​(Pair<X0,​X1> tuple)
      • addAt1

        public <X0,​X1> Triplet<A,​X0,​X1> addAt1​(Pair<X0,​X1> tuple)
      • addAt0

        public <X0,​X1,​X2> Quartet<X0,​X1,​X2,​A> addAt0​(Triplet<X0,​X1,​X2> tuple)
      • addAt1

        public <X0,​X1,​X2> Quartet<A,​X0,​X1,​X2> addAt1​(Triplet<X0,​X1,​X2> tuple)
      • addAt0

        public <X0,​X1,​X2,​X3> Quintet<X0,​X1,​X2,​X3,​A> addAt0​(Quartet<X0,​X1,​X2,​X3> tuple)
      • addAt1

        public <X0,​X1,​X2,​X3> Quintet<A,​X0,​X1,​X2,​X3> addAt1​(Quartet<X0,​X1,​X2,​X3> tuple)
      • addAt0

        public <X0,​X1,​X2,​X3,​X4> Sextet<X0,​X1,​X2,​X3,​X4,​A> addAt0​(Quintet<X0,​X1,​X2,​X3,​X4> tuple)
      • addAt1

        public <X0,​X1,​X2,​X3,​X4> Sextet<A,​X0,​X1,​X2,​X3,​X4> addAt1​(Quintet<X0,​X1,​X2,​X3,​X4> tuple)
      • addAt0

        public <X0,​X1,​X2,​X3,​X4,​X5> Septet<X0,​X1,​X2,​X3,​X4,​X5,​A> addAt0​(Sextet<X0,​X1,​X2,​X3,​X4,​X5> tuple)
      • addAt1

        public <X0,​X1,​X2,​X3,​X4,​X5> Septet<A,​X0,​X1,​X2,​X3,​X4,​X5> addAt1​(Sextet<X0,​X1,​X2,​X3,​X4,​X5> tuple)
      • addAt0

        public <X0,​X1,​X2,​X3,​X4,​X5,​X6> Octet<X0,​X1,​X2,​X3,​X4,​X5,​X6,​A> addAt0​(Septet<X0,​X1,​X2,​X3,​X4,​X5,​X6> tuple)
      • addAt1

        public <X0,​X1,​X2,​X3,​X4,​X5,​X6> Octet<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6> addAt1​(Septet<X0,​X1,​X2,​X3,​X4,​X5,​X6> tuple)
      • addAt0

        public <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7> Ennead<X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​A> addAt0​(Octet<X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7> tuple)
      • addAt1

        public <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7> Ennead<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7> addAt1​(Octet<X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7> tuple)
      • addAt0

        public <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8> Decade<X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8,​A> addAt0​(Ennead<X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8> tuple)
      • addAt1

        public <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8> Decade<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8> addAt1​(Ennead<X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8> tuple)
      • add

        public <X0> Pair<A,​X0> add​(X0 value0)
      • add

        public <X0> Pair<A,​X0> add​(Unit<X0> tuple)
      • add

        public <X0,​X1> Triplet<A,​X0,​X1> add​(X0 value0,
                                                              X1 value1)
      • add

        public <X0,​X1> Triplet<A,​X0,​X1> add​(Pair<X0,​X1> tuple)
      • add

        public <X0,​X1,​X2> Quartet<A,​X0,​X1,​X2> add​(X0 value0,
                                                                                X1 value1,
                                                                                X2 value2)
      • add

        public <X0,​X1,​X2> Quartet<A,​X0,​X1,​X2> add​(Triplet<X0,​X1,​X2> tuple)
      • add

        public <X0,​X1,​X2,​X3> Quintet<A,​X0,​X1,​X2,​X3> add​(X0 value0,
                                                                                                  X1 value1,
                                                                                                  X2 value2,
                                                                                                  X3 value3)
      • add

        public <X0,​X1,​X2,​X3> Quintet<A,​X0,​X1,​X2,​X3> add​(Quartet<X0,​X1,​X2,​X3> tuple)
      • add

        public <X0,​X1,​X2,​X3,​X4> Sextet<A,​X0,​X1,​X2,​X3,​X4> add​(X0 value0,
                                                                                                                   X1 value1,
                                                                                                                   X2 value2,
                                                                                                                   X3 value3,
                                                                                                                   X4 value4)
      • add

        public <X0,​X1,​X2,​X3,​X4> Sextet<A,​X0,​X1,​X2,​X3,​X4> add​(Quintet<X0,​X1,​X2,​X3,​X4> tuple)
      • add

        public <X0,​X1,​X2,​X3,​X4,​X5> Septet<A,​X0,​X1,​X2,​X3,​X4,​X5> add​(X0 value0,
                                                                                                                                     X1 value1,
                                                                                                                                     X2 value2,
                                                                                                                                     X3 value3,
                                                                                                                                     X4 value4,
                                                                                                                                     X5 value5)
      • add

        public <X0,​X1,​X2,​X3,​X4,​X5> Septet<A,​X0,​X1,​X2,​X3,​X4,​X5> add​(Sextet<X0,​X1,​X2,​X3,​X4,​X5> tuple)
      • add

        public <X0,​X1,​X2,​X3,​X4,​X5,​X6> Octet<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6> add​(X0 value0,
                                                                                                                                                      X1 value1,
                                                                                                                                                      X2 value2,
                                                                                                                                                      X3 value3,
                                                                                                                                                      X4 value4,
                                                                                                                                                      X5 value5,
                                                                                                                                                      X6 value6)
      • add

        public <X0,​X1,​X2,​X3,​X4,​X5,​X6> Octet<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6> add​(Septet<X0,​X1,​X2,​X3,​X4,​X5,​X6> tuple)
      • add

        public <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7> Ennead<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7> add​(X0 value0,
                                                                                                                                                                         X1 value1,
                                                                                                                                                                         X2 value2,
                                                                                                                                                                         X3 value3,
                                                                                                                                                                         X4 value4,
                                                                                                                                                                         X5 value5,
                                                                                                                                                                         X6 value6,
                                                                                                                                                                         X7 value7)
      • add

        public <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7> Ennead<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7> add​(Octet<X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7> tuple)
      • add

        public <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8> Decade<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8> add​(X0 value0,
                                                                                                                                                                                           X1 value1,
                                                                                                                                                                                           X2 value2,
                                                                                                                                                                                           X3 value3,
                                                                                                                                                                                           X4 value4,
                                                                                                                                                                                           X5 value5,
                                                                                                                                                                                           X6 value6,
                                                                                                                                                                                           X7 value7,
                                                                                                                                                                                           X8 value8)
      • add

        public <X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8> Decade<A,​X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8> add​(Ennead<X0,​X1,​X2,​X3,​X4,​X5,​X6,​X7,​X8> tuple)
      • setAt0

        public <X> Unit<X> setAt0​(X value)