Programación D - Tuplas

Las tuplas se utilizan para combinar varios valores como un solo objeto. Tuples contiene una secuencia de elementos. Los elementos pueden ser tipos, expresiones o alias. El número y los elementos de una tupla se fijan en tiempo de compilación y no se pueden cambiar en tiempo de ejecución.

Las tuplas tienen características tanto de estructuras como de matrices. Los elementos de tupla pueden ser de diferentes tipos, como estructuras. Se puede acceder a los elementos mediante indexación como matrices. Se implementan como una función de biblioteca mediante la plantilla Tuple del módulo std.typecons. Tuple hace uso de TypeTuple del módulo std.typetuple para algunas de sus operaciones.

Tupla usando tupla ()

Las tuplas se pueden construir mediante la función tuple (). Se accede a los miembros de una tupla mediante valores de índice. A continuación se muestra un ejemplo.

Ejemplo

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

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

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

Tupla usando la plantilla de tupla

Tuple también se puede construir directamente con la plantilla Tuple en lugar de la función tuple (). El tipo y el nombre de cada miembro se especifican como dos parámetros de plantilla consecutivos. Es posible acceder a los miembros por propiedades cuando se crean usando plantillas.

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

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado

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

Ampliación de parámetros de función y propiedad

Los miembros de Tuple se pueden expandir mediante la propiedad .expand o mediante la división. Este valor expandido / dividido se puede pasar como lista de argumentos de función. A continuación se muestra un ejemplo.

Ejemplo

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..$]); 
}

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

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

TipoTupla

TypeTuple se define en el módulo std.typetuple. Una lista de valores y tipos separados por comas. A continuación se ofrece un ejemplo sencillo con TypeTuple. TypeTuple se utiliza para crear una lista de argumentos, una lista de plantillas y una lista literal de matriz.

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

Cuando se compila y ejecuta el código anterior, produce el siguiente resultado:

method 1 5 my string 3.3 r 
5     6