La caccia al tesoro di Tisbury

Una Tuple è molto simile a un Vector (un array monodimensionale) sotto molti aspetti. Tuttavia, ci sono alcune differenze importanti.

• Le tuple si scrivono tra parentesi tonde ( ) invece che tra parentesi quadre [ ], anche se le parentesi tonde si possono omettere nei casi in cui il significato è inequivocabile.
• Le tuple non devono essere omogenee: il tipo di ogni elemento è memorizzato in modo indipendente.
• Le tuple sono immutabili.

L'immutabilità consente al compilatore più ottimizzazioni e rende le tuple più performanti degli array, quindi è preferibile usarle quando la mutabilità non è necessaria.

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

Esiste anche un costruttore Tuple(), che trasforma qualsiasi collezione iterabile in una tupla. Utile a sapersi: tratta una stringa come una collezione iterabile di caratteri.

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

Per qualsiasi tupla, è possibile accedere agli elementi tramite l'indice o iterare su di essi.

Qualsiasi tupla puramente numerica può anche essere usata nelle funzioni matematiche come sum(), esattamente come gli array.

Scomposizione

Una tupla può essere scomposta nei singoli elementi usando l'assegnazione multipla. Per gli elementi che non servono, usa il trattino basso _ come variabile fittizia.

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

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

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

Chi programma in Python ha sicuramente familiarità con questa sintassi di assegnazione multipla.

Tuple con nome

Una Tuple contiene solo valori. Una NamedTuple associa ogni valore a un nome.

I singoli campi si possono poi accedere con la notazione «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

Il nome è memorizzato internamente come Symbol (un tipo immutabile, preceduto da due punti :), quindi è disponibile una sintassi alternativa:

julia> nt[:b]
7.3

È facile ottenere separatamente sia i nomi (chiamati anche «chiavi») sia i valori:

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

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

julia> values(nt)
(1, 7.3)

Nota che l'iterazione su una tupla con nome produce solo i valori, mentre i nomi vengono ignorati.

Le tuple (con nome o meno) sono un modo molto comune per trasferire dati strutturati da e verso le funzioni. L'immutabilità è un vantaggio in questo caso d'uso, perché garantisce la sicurezza dei dati e consente ottimizzazioni più aggressive da parte del compilatore.