La chasse au trésor de Tisbury

Un Tuple est assez proche d'un Vector (un array à 1 dimension) à bien des égards. Il y a toutefois quelques différences importantes.

• Les tuples s'écrivent avec des parenthèses ( ) plutôt qu'avec des crochets [ ], même si les parenthèses peuvent être omises quand le sens est sans ambiguïté.
• Les tuples n'ont pas besoin d'être homogènes : le type de chaque élément est stocké indépendamment.
• Les tuples sont immuables.

L'immuabilité permet davantage d'optimisations du compilateur et rend les tuples plus performants que les vecteurs, il faut donc les préférer quand la mutabilité n'est pas nécessaire.

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

Il existe aussi un constructeur Tuple(), qui transforme n'importe quelle collection itérable en tuple. C'est pratique : il traite une string comme une collection itérable de caractères.

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

Pour n'importe quel tuple, on peut accéder aux éléments par leur indice ou les parcourir avec une boucle.

Tout tuple purement numérique peut aussi être utilisé dans des fonctions mathématiques comme sum(), exactement comme les tableaux.

Déballe

On peut déballer un tuple en éléments individuels grâce à l'affectation multiple. Pour les éléments dont on n'a pas besoin, on utilise un tiret bas _ comme variable factice.

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

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

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

Les développeurs Python connaissent très bien cette syntaxe d'affectation multiple.

Tuples nommés

Un Tuple ne contient que des valeurs. Un NamedTuple associe chaque valeur à un nom.

On peut alors accéder aux différents champs avec la « notation par point » :

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

Le nom est stocké en interne sous la forme d'un Symbol (un type immuable, précédé d'un deux-points :), une syntaxe alternative est donc disponible :

julia> nt[:b]
7.3

Il est facile d'obtenir séparément les noms (aussi appelés « clés ») ou les valeurs :

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

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

julia> values(nt)
(1, 7.3)

À noter que parcourir un tuple nommé ne produit que les valeurs, et que les noms sont ignorés.

Les tuples (nommés ou non) sont un moyen très courant de transférer des données structurées vers et depuis des fonctions. L'immuabilité est ici un atout : elle assure la sécurité des données et permet des optimisations du compilateur plus poussées.