Un tuple est un regroupement de deux expressions ou plus qui est traité comme une seule expression.
Un littéral de tuple comporte plusieurs expressions entre (), les éléments étant séparés par des virgules :
(1, 2, 3)
L'ordre des éléments d'un tuple est important. Le tuple suivant est différent de l'exemple de tuple précédent :
(3, 2, 1)
La même expression peut également se trouver à plusieurs endroits dans un tuple :
("Help me Rhonda", "Help", "Help me Rhonda")
Les expressions de tuple peuvent être de n'importe quel type et contenir des types mixtes (contrairement aux matrices, qui ne peuvent avoir que des éléments d'un seul type) :
(1, 2.0, "three")
Les tuples peuvent même contenir d'autres tuples :
(1, (10, 20.0, "thirty"), "three")
Si ces termes vous sont familiers, un tuple est comme :
- Une structure de données sans nom avec des éléments ordonnés sans nom.
- Une matrice à taille fixe où chaque élément peut être d'un type différent.
Les tuples sont particulièrement utiles pour :
- lors du renvoi de plusieurs valeurs à partir d'une fonction ;
- Un simple regroupement qui est plus concis que le traitement de création d'une structure de données entièrement décrite et réutilisable (telle qu'une struct ou une [classe] (class-in-verse)).
Spécifier une variable avec un type de tuple
Pour spécifier le type de variable en tant que tuple, le préfixe tuple est utilisé devant les types séparés par des virgules et entourés de () :
MyTupleInts : tuple(int, int, int) = (1, 2, 3)
MyTupleMixed : tuple(int, float, string) = (1, 2.0, "three")
MyTupleNested : tuple(int, tuple(int, float, string), string) = (1, (10, 20.0, "thirty"), "three")
Les types de tuple peuvent également être [déduits] (verse-glossary#infer) :
MyTupleInts := (1, 2, 3)
MyTupleMixed := (1, 2.0, "three")
MyTupleNested := (1, (10, 20.0, "thirty"), "three")
Les [spécificateurs] (verse-glossary#specifier) de type tuple peuvent être utilisés dans les [membres] (verse-glossary#member) de données et les [signatures de type de fonction] (verse-glossary#function-signature) pour les paramètres ou un type de [renvoi] (verse-glossary#return) :
ExampleFunction(Param1 : tuple(string, int), Param2 : tuple(int, string)) : tuple(string, int) =
# Utilisation d'un paramètre comme résultat
Param1
Accès à l'élément Tuple
On peut accéder aux éléments d'un tuple avec un opérateur d'index non faillible, basé sur zéro, qui prend un entier. L'opérateur d'index ne peut pas échouer (contrairement à l'opérateur d'index de matrice [index]), parce que le compilateur connaît toujours le nombre d'éléments de n'importe quel tuple et donc tout index hors limites sera une erreur de compilation :
MyTuple := (1, 2.0, "three")
MyNestedTuple := (1, (10, 20.0, "thirty"), "three")
var MyInt: int = MyTuple(0)
var MyFloat: float = MyTuple(1)
var MyString: string = MyTuple(2)
Print("My variables: {MyInt}, {MyFloat}, {MyString}")
Print("My nested tuple element: {MyNestedTuple(1)(2)}")
Forçage des matrices de tuple
Les tuples peuvent être passés partout où une matrice est attendue, à condition que le type des éléments du tuple soit le même que celui de la matrice. Les matrices ne peuvent pas être passées là où un tuple est attendu.
Expansion de tuple
Un tuple passé comme élément unique à une fonction se comportera comme si cette fonction était appelée avec chacun des éléments de ce tuple séparément. C'est ce qu'on appelle l'expansion de tuple ou [projection] (verse-glossary#splat).
F(Arg1 : int, Arg2 : string) : void =
DoStuff(Arg1, Arg2)
G() : void =
MyTuple := (1, "two")
F(MyTuple(0), MyTuple(1)) # Accès aux éléments
F(MyTuple) # Expansion de tuple
L'expression de concurrence structurée sync possède un résultat de tuple qui permet d'évaluer simultanément plusieurs arguments dans le temps. Pour en savoir plus, consultez la page Flux temporel et concurrence.
Type persistant
Un tuple est persistant si chaque type d'élément du tuple est persistant. Cela signifie que vous pouvez utiliser un tuple persistant dans vos variables weak_map à étendue de module et faire persister leurs valeurs d'une session de jeu à une autre. Pour en savoir plus sur la persistance dans Verse, consultez Utiliser des données persistantes dans Verse.