Una tupla consiste en una agrupación de dos o más expresiones que se trata como una única expresión.
Un literal de tupla tiene varias expresiones entre (), con los elementos separados por comas:
(1, 2, 3)
El orden de los elementos de una tupla es importante. La siguiente tupla es diferente al ejemplo de la tupla anterior:
(3, 2, 1)
La misma expresión también puede estar en varias posiciones de una tupla:
("Help me Rhonda", "Help", "Help me Rhonda")
Las expresiones de tupla pueden ser de cualquier tipo y pueden contener varios tipos (a diferencia de las matrices, que solo pueden tener elementos de un tipo):
(1, 2.0, "three")
Las tuplas pueden incluso contener otras tuplas:
(1, (10, 20.0, "thirty"), "three")
Si te suenan estos términos, una tupla es como:
- Una estructura de datos sin nombre con elementos ordenados sin nombre.
- Una matriz de tamaño fijo en la que cada elemento puede ser de un tipo diferente.
Las tuplas son especialmente útiles para:
- Devolver varios valores desde una función.
- Una simple agrupación que es más concisa que la sobrecarga de hacer una estructura de datos totalmente descrita y reutilizable (como una estructura o una [clase])(class-in-verse)).
Especificación de una variable con un tipo de tupla
Para especificar el tipo de variable como una tupla, se utiliza el prefijo tuple antes de los tipos separados por comas entre ():
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")
Los tipos de tupla también se pueden inferir:
MyTupleInts := (1, 2, 3)
MyTupleMixed := (1, 2.0, "three")
MyTupleNested := (1, (10, 20.0, "thirty"), "three")
Los especificadores de tipo tupla pueden utilizarse en miembros de datos y firmas de tipo de función para parámetros o un tipo de valor devuelto:
ExampleFunction(Param1 : tuple(string, int), Param2 : tuple(int, string)) : tuple(string, int) =
# Uso de un parámetro como resultado
Param1
Acceso a elementos de tuplas
Se puede acceder a los elementos de una tupla con un operador de índice no fallido y base cero que tome un entero. El operador de índice no puede fallar (a diferencia del [index] del operador de índice de matriz, que sí puede fallar) porque el compilador siempre conoce el número de elementos de cualquier tupla y, por tanto, cualquier índice fuera de los límites generará un error de tiempo de compilación:
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("Mis variables: {MyInt}, {MyFloat}, {MyString}")
Print("Mi elemento de tupla anidada: {MyNestedTuple(1)(2)}")
Coerción de matrices de tuplas
Las tuplas pueden pasarse allí donde se espera una matriz, siempre que el tipo de los elementos de la tupla coincidan con el tipo de la matriz. No se pueden pasar matrices donde se espera una tupla.
Expansión de tupla
Una tupla pasada como un solo elemento a una función será como si esa función fuera llamada con cada uno de los elementos de esa tupla por separado. Esto recibe el nombre de expansión de tupla o dispersión.
F(Arg1 : int, Arg2 : string) : void =
DoStuff(Arg1, Arg2)
G() : void =
MyTuple := (1, "two")
F(MyTuple(0), MyTuple(1)) # Acceso a los elementos
F(MyTuple) # Expansión de la tupla
La expresión sync de simultaneidad estructurada tiene un resultado de tupla que permite que varios argumentos evalúen el tiempo para una evaluación simultánea. Para obtener más información, consulta Simultaneidad.
Tipo persistente
Una tupla es persistente si cada tipo de elemento es persistente. Cuando una tupla es persistente, significa que puedes usarla en tus variables weak_map de tu ámbito de módulo y hacer que sus valores se mantengan a lo largo de las sesiones de juego. Para obtener más información sobre la persistencia en Verse, consulta la sección Cómo utilizar datos persistentes en Verse.