# Tuple

Tuples are similar to arrays, but can hold objects of different types. Such a collection is called an unequal collection. In contrast, homogeneous collections include arrays, sets, etc.

``````t = (1, True, "a")
(i, b, s) = t
assert(i == 1 and b == True and s == "a")
``````

The tuple `t` can retrieve the nth element in the form `t.n`; note that unlike Python, it is not `t[n]`. This is because accessing tuple elements is more like an attribute (the existence of the element is checked at compile time, and the type can change depending on `n`) than a method (an array's `[]` is a method).

``````assert t.0 == 1
assert t.1 == True
assert t.2 == "a"
``````

Parentheses `()` are optional when not nested.

``````t = 1, True, "a"
i, b, s = t
``````

Tuples can hold objects of different types, so they cannot be iterated like arrays.

``````t: ({1}, {2}, {3}) = (1, 2, 3)
(1, 2, 3).iter().map(x -> x + 1) # TypeError: type ({1}, {2}, {3}) has no method `.iter()`
``````
``````# If all types are the same, they can be represented by `(T; n)` like arrays, but this still does not allow iteration
t: (Int; 3) = (1, 2, 3)
assert (Int; 3) == (Int, Int, Int)
``````

However, nonhomogeneous collections (such as tuples) can be converted to homogeneous collections (such as arrays) by upcasting, intersecting, and so on. This is called equalization.

``````(Int, Bool, Str) can be [T; 3] where T :> Int, T :> Bool, T :> Str
``````
``````t: (Int, Bool, Str) = (1, True, "a") # non-homogenous
a: [Int or Bool or Str; 3] = [1, True, "a"] # homogenous
_a: [Show; 3] = [1, True, "a"] # homogenous
_a.iter().map(x -> log x) # OK
t.try_into([Show; 3])? .iter().map(x -> log x) # OK
``````

## Unit

A tuple with zero elements is called a unit. A unit is a value, but also refers to its own type.

``````unit = ()
(): ()
``````

Unit is a superclass of all tuples.

``````() :> (Int; 0)
() :> (Str; 0)
() :> (Int, Str)
...
``````

The use of this object is for procedures with no arguments and no return value, etc. Erg subroutines must have arguments and a return value. However, in some cases, such as a procedure, there may be no meaningful arguments or return value, only side effects. In such cases, we use units as "meaningless, formal values.

``````p!() =.
# `print!` does not return a meaningful value
print! "Hello, world!"
p!: () => () # The parameter part is part of the syntax, not a tuple
``````

However, Python tends to use `None` instead of units in such cases. In Erg, you should use `()` when you are sure from the beginning that the operation will not return a meaningful value, such as in a procedure, and return `None` when there is a possibility that the operation will fail and you will get nothing, such as when retrieving an element.