Caça ao Tesouro de Tisbury

Um Tuple é bastante parecido com um Vector (um array unidimensional) em muitos aspectos. No entanto, há algumas diferenças importantes.

• As tuplas são escritas entre parênteses ( ) em vez de colchetes [ ], embora os parênteses possam ser omitidos quando o significado não é ambíguo.
• As tuplas não precisam 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 que os vetores, então elas devem ser preferidas quando 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})

Também existe um construtor Tuple(), que transforma qualquer coleção iterável em uma tupla. De forma útil, ele trata uma string como uma coleção iterável de caracteres.

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

Para qualquer tupla, é possível acessar os 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 arrays.

Desempacotamento

Uma tupla pode ser desempacotada em elementos individuais usando atribuição múltipla. Para elementos que não são necessários, use o sublinhado _ como variável descartável.

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 já conhece bem essa sintaxe de atribuição múltipla.

Tuplas nomeadas

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

Os campos individuais podem então ser acessados 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, prefixado com dois-pontos :), então há uma sintaxe alternativa disponível:

julia> nt[:b]
7.3

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

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

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

julia> values(nt)
(1, 7.3)

Repare 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 nesse caso, pois oferece segurança dos dados e permite otimizações mais agressivas do compilador.