Programmation en D - Tuples

Les tuples sont utilisés pour combiner plusieurs valeurs en un seul objet. Les tuples contiennent une séquence d'éléments. Les éléments peuvent être des types, des expressions ou des alias. Le nombre et les éléments d'un tuple sont fixés au moment de la compilation et ils ne peuvent pas être modifiés au moment de l'exécution.

Les tuples ont des caractéristiques à la fois des structures et des tableaux. Les éléments de tuple peuvent être de différents types comme les structures. Les éléments sont accessibles via l'indexation comme des tableaux. Ils sont implémentés en tant que fonctionnalité de bibliothèque par le modèle Tuple du module std.typecons. Tuple utilise TypeTuple du module std.typetuple pour certaines de ses opérations.

Tuple utilisant tuple ()

Les tuples peuvent être construits par la fonction tuple (). Les membres d'un tuple sont accessibles par des valeurs d'index. Un exemple est présenté ci-dessous.

Exemple

import std.stdio; 
import std.typecons; 
 
void main() { 
   auto myTuple = tuple(1, "Tuts"); 
   writeln(myTuple); 
   writeln(myTuple[0]); 
   writeln(myTuple[1]); 
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Tuple!(int, string)(1, "Tuts") 
1 
Tuts

Tuple à l'aide du modèle Tuple

Tuple peut également être construit directement par le modèle Tuple au lieu de la fonction tuple (). Le type et le nom de chaque membre sont spécifiés comme deux paramètres de modèle consécutifs. Il est possible d'accéder aux membres par propriétés lors de leur création à l'aide de modèles.

import std.stdio; 
import std.typecons; 

void main() { 
   auto myTuple = Tuple!(int, "id",string, "value")(1, "Tuts"); 
   writeln(myTuple);  
   
   writeln("by index 0 : ", myTuple[0]); 
   writeln("by .id : ", myTuple.id); 
   
   writeln("by index 1 : ", myTuple[1]); 
   writeln("by .value ", myTuple.value); 
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant

Tuple!(int, "id", string, "value")(1, "Tuts") 
by index 0 : 1 
by .id : 1 
by index 1 : Tuts 
by .value Tuts

Expansion des paramètres de propriété et de fonction

Les membres de Tuple peuvent être développés soit par la propriété .expand, soit par découpage. Cette valeur développée / découpée peut être transmise comme liste d'arguments de fonction. Un exemple est présenté ci-dessous.

Exemple

import std.stdio; 
import std.typecons;
 
void method1(int a, string b, float c, char d) { 
   writeln("method 1 ",a,"\t",b,"\t",c,"\t",d); 
}
 
void method2(int a, float b, char c) { 
   writeln("method 2 ",a,"\t",b,"\t",c); 
}
 
void main() { 
   auto myTuple = tuple(5, "my string", 3.3, 'r'); 
   
   writeln("method1 call 1"); 
   method1(myTuple[]); 
   
   writeln("method1 call 2"); 
   method1(myTuple.expand); 
   
   writeln("method2 call 1"); 
   method2(myTuple[0], myTuple[$-2..$]); 
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

method1 call 1 
method 1 5 my string 3.3 r
method1 call 2 
method 1 5 my string 3.3 r 
method2 call 1 
method 2 5 3.3 r

TypeTuple

TypeTuple est défini dans le module std.typetuple. Une liste de valeurs et de types séparés par des virgules. Un exemple simple utilisant TypeTuple est donné ci-dessous. TypeTuple est utilisé pour créer une liste d'arguments, une liste de modèles et une liste littérale de tableau.

import std.stdio; 
import std.typecons; 
import std.typetuple; 
 
alias TypeTuple!(int, long) TL;  

void method1(int a, string b, float c, char d) { 
   writeln("method 1 ",a,"\t",b,"\t",c,"\t",d); 
} 

void method2(TL tl) { 
   writeln(tl[0],"\t", tl[1] ); 
} 
 
void main() { 
   auto arguments = TypeTuple!(5, "my string", 3.3,'r');  
   method1(arguments); 
   method2(5, 6L);  
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

method 1 5 my string 3.3 r 
5     6