Una tupla consiste nel raggruppamento di più espressioni in una.
Una tupla letterale ha espressioni multiple tra (), con gli elementi separati da virgole:
(1, 2, 3)
L'ordine degli elementi in una tupla è importante. La tupla seguente è diversa dall'esempio di tupla precedente:
(3, 2, 1)
La stessa espressione può anche essere presente in più posizioni di una tupla:
("Aiutami Rhonda", "Aiuto", "Aiutami Rhonda")
Le espressioni di tupla possono essere di qualsiasi tipo e possono contenere tipi misti (a differenza degli array che possono avere elementi di un solo tipo):
(1, 2.0, "three")
Le tuple possono anche contenere altre tuple:
(1, (10, 20.0, "thirty"), "three")
Se hai familiarità con questi termini, una tupla è come:
- Una struttura dati senza nome con elementi ordinati senza nome
- Un array di dimensioni fisse in cui ogni elemento può essere di tipo diverso
Le tuple sono particolarmente utili per:
- Restituire più valori da una funzione.
- Un semplice raggruppamento sul posto, più conciso rispetto al sovraccarico di una struttura di dati completamente descritta e riutilizzabile (come una struttura o classe).
Specificare una variabile con un tipo di tupla
Per specificare il tipo di variabile come tupla, si usa il prefisso tuple prima dei tipi separati da virgole e racchiusi in ():
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")
I tipi di tupla possono anche essere [ricavati] (verse-glossary#infer):
MyTupleInts := (1, 2, 3)
MyTupleMixed := (1, 2.0, "three")
MyTupleNested := (1, (10, 20.0, "thirty"), "three")
Gli specificatori di tipo tupla possono essere usati nei membri dei dati e nelle firme dei tipi di funzione per i parametri o per un tipo [return] (verse-glossary#return):
ExampleFunction(Param1 : tuple(string, int), Param2 : tuple(int, string)) : tuple(string, int) =
# Usare un parametro come risultato
Param1
Accesso agli elementi di una tupla
Si può accedere agli elementi di una tupla con un indice operatore non fallato e basato su zero, che prende un intero. L'operatore indice non può fallire (a differenza dell'operatore indice di un array [index] che può fallire) perché il compilatore conosce sempre il numero di elementi di qualsiasi tupla e quindi qualsiasi indice fuori limite sarà un errore compile-time:
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("Le mie variabili: {MyInt}, {MyFloat}, {MyString}")
Print("Il mio elemento tupla annidato: {MyNestedTuple(1)(2)}")
Coercizione array di tupla
Le tuple si possono passare ovunque sia previsto un array, purché il tipo degli elementi della tupla sia dello stesso tipo dell'array. Non si possono passare array dove è prevista una tupla.
Espansione della tupla
Una tupla passata come singolo elemento a una funzione sarà come se la funzione fosse chiamata con ciascuno degli elementi della tupla separatamente. Ciò è chiamato espansione della tupla o spiattellamento.
F(Arg1 : int, Arg2 : string) : void =
DoStuff(Arg1, Arg2)
G() : void =
MyTuple := (1, "two")
F(MyTuple(0), MyTuple(1)) # Accesso agli elementi
F(MyTuple) # Espansione della tupla
L'espressione sync concorrenza strutturata ha un risultato della tupla che consente di valutare simultaneamente diversi argomenti che valutano nel tempo. Per maggiori informazioni, vedi Concorrenza.
Tipo persistente
Una tupla è persistente se ogni tipo di elemento nella tupla è persistente. Quando una tupla è persistente, significa che puoi utilizzarle nelle variabili weak_map, che sono sottoposte a scansione del modulo, e che i loro valori persistono nelle varie sessioni di gioco. Per maggiori dettagli sulla persistenza in Verse, consulta Utilizzo dei dati persistenti in Verse.