La búsqueda del tesoro de Tisbury

Una Tuple es bastante similar a un Vector (un array unidimensional) en muchos aspectos. Sin embargo, hay algunas diferencias importantes.

• Las tuplas se escriben entre paréntesis ( ) en lugar de corchetes [ ], aunque los paréntesis se pueden omitir en los casos en que el significado no sea ambiguo.
• Las tuplas no tienen que ser homogéneas: el tipo de cada elemento se almacena de forma independiente.
• Las tuplas son inmutables.

La inmutabilidad permite más optimizaciones del compilador y hace que las tuplas rindan mejor que los vectores, así que conviene preferirlas cuando la mutabilidad no sea necesaria.

julia> t = (3, 5.2, "xyz")
(3, 5.2, "xyz")

# Non-homogeneous:
julia> dump(t)
Tuple{Int64, Float64, String}
  1: Int64 3
  2: Float64 5.2
  3: String "xyz"

julia> t[2]
5.2

# Immutable:
julia> t[2] = 7.3
ERROR: MethodError: no method matching setindex!(::Tuple{Int64, Float64, String})

También hay un constructor Tuple(), que convierte cualquier colección iterable en una tupla. De forma útil, esto trata un string como una colección iterable de caracteres.

julia> Tuple("Julia")
('J', 'u', 'l', 'i', 'a')

Para cualquier tupla, es posible acceder a los elementos por índice o recorrerlos.

Cualquier tupla puramente numérica también se puede usar en funciones matemáticas como sum(), exactamente igual que los arrays.

Desempaquetado

Una tupla se puede desempaquetar en elementos individuales mediante asignación múltiple. Para los elementos que no se necesiten, usa el guion bajo _ como variable ficticia.

julia> tup = (1, "Julia", true)
(1, "Julia", true)

julia> num, name, _ = tup
(1, "Julia", true)

julia> uppercase(name), 2num
("JULIA", 2)

Quienes programan en Python estarán muy familiarizados con esta sintaxis de asignación múltiple.

Tuplas con nombre

Una Tuple solo contiene valores. Un NamedTuple asocia cada valor con un nombre.

Los campos individuales se pueden consultar con la notación de punto:

julia> nt = (a = 1, b = 7.3)
(a = 1, b = 7.3)

julia> dump(nt)
@NamedTuple{a::Int64, b::Float64}
  a: Int64 1
  b: Float64 7.3

julia> nt.b
7.3

El nombre se almacena internamente como un Symbol (un tipo inmutable, precedido por dos puntos :), así que hay una sintaxis alternativa disponible:

julia> nt[:b]
7.3

Es fácil obtener los nombres (también llamados «claves») o los valores por separado:

julia> nt
(a = 1, b = 7.3)

julia> keys(nt)
(:a, :b)

julia> values(nt)
(1, 7.3)

Ten en cuenta que la iteración sobre una tupla con nombre solo produce los valores, y los nombres se ignoran.

Las tuplas (con nombre o no) son una forma muy común de transferir datos estructurados hacia y desde funciones. La inmutabilidad es buena en este caso de uso, ya que proporciona seguridad de los datos y permite optimizaciones del compilador más agresivas.