Caça ao Tesouro de Tisbury

Uma Tuple é bastante semelhante a um Vector (um array 1-D) em muitos aspetos. No entanto, há algumas diferenças importantes.

• As tuplas escrevem-se entre parênteses ( ) em vez de parênteses retos [ ], embora os parênteses possam ser omitidos nos casos em que o significado não é ambíguo.
• As tuplas não são obrigadas a ser homogéneas: o tipo de cada elemento é armazenado de forma independente.
• As tuplas são imutáveis.

A imutabilidade permite mais otimizações do compilador e torna as tuplas mais eficientes do que os vetores, por isso devem ser preferidas nos casos em que a mutabilidade não é necessária.

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})

Existe também um construtor Tuple(), que transforma qualquer coleção iterável numa tupla. Convenientemente, isto trata uma string como uma coleção iterável de carateres.

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

Em qualquer tupla, é possível aceder aos elementos por índice ou iterar sobre eles.

Qualquer tupla puramente numérica também pode ser usada em funções matemáticas como sum(), exatamente como os arrays.

Desempacotamento

Uma tupla pode ser desempacotada em elementos individuais recorrendo a atribuição múltipla. Para os elementos que não são necessários, usa o sublinhado _ como variável fictícia.

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

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

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

Quem programa em Python está muito familiarizado com esta sintaxe de atribuição múltipla.

Tuplas nomeadas

Uma Tuple contém apenas valores. Uma NamedTuple associa cada valor a um nome.

Os campos individuais podem depois ser acedidos com a notação de "ponto":

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

O nome é armazenado internamente como um Symbol (um tipo imutável, precedido de dois pontos :), por isso também existe uma sintaxe alternativa:

julia> nt[:b]
7.3

É fácil obter os nomes (também chamados "chaves") ou os valores separadamente:

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

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

julia> values(nt)
(1, 7.3)

Repara que a iteração sobre uma tupla nomeada produz apenas os valores, e os nomes são ignorados.

As tuplas (nomeadas ou não) são uma forma muito comum de transferir dados estruturados de e para funções. A imutabilidade é boa neste caso de uso, pois proporciona segurança dos dados e permite otimizações mais agressivas do compilador.