La búsqueda del tesoro de Tisbury

Una Tuple es muy 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 cuando el significado no es 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 tengan mejor rendimiento que los vectores, así que conviene preferirlas cuando no se necesita mutabilidad.

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 existe un constructor Tuple(), que convierte cualquier colección iterable en una tupla. Algo muy útil: trata un string como una colección iterable de caracteres.

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

En cualquier tupla es posible acceder a los elementos por índice o recorrerlos con un bucle.

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

Desempaquetado

Una tupla se puede desempaquetar en elementos individuales usando asignación múltiple. Para los elementos que no necesitas, 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. Una NamedTuple asocia cada valor con un nombre.

Cada campo se puede acceder luego 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 por separado los nombres (también llamados «claves») o los valores:

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

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

julia> values(nt)
(1, 7.3)

Ten en cuenta que al iterar sobre una tupla con nombre solo se producen los valores, y los nombres se ignoran.

Las tuplas (con nombre o no) son una forma muy común de transferir datos estructurados desde y hacia las funciones. La inmutabilidad viene muy bien en este caso: aporta seguridad a los datos y permite optimizaciones del compilador más agresivas.