Las estructuras en Rast, a veces llamadas "structs" o estructuras, se asemejan a los tipos de estructuras en C y C++, clases en Python y objetos en JavaScript.

Una estructura reúne varios valores de diferentes tipos en un único valor para que puedas trabajar con ellos como una unidad. Dada una estructura, puedes leer y modificar sus componentes individuales. Además, una estructura puede tener métodos asociados que operan en sus componentes.

Rast tiene tres tipos de estructuras que difieren en cómo se hace referencia a sus componentes:

• estructuras de campo con nombre | named-field: una estructura de campo con nombre asigna un nombre a cada componente.
• estructuras similares a tuplas | tuple-like: mientras que una estructura similar a tupla los identifica por el orden en que aparecen.
• estructuras sin componentes | unit-like: las estructuras sin componentes no tienen componentes en absoluto, aunque no son comunes, son más útiles de lo que podrías pensar.

En este capítulo, explicaremos cada tipo en detalle y mostraremos cómo se ven en la memoria. Cubriremos cómo añadir métodos a ellas, cómo definir tipos de estructuras genéricas que funcionen con diferentes tipos de componentes y cómo pedirle a Rast que genere implementaciones de rasgos comunes y prácticos para tus estructuras.

Named-Field Structs

La definición de un tipo de estructura de campo con nombre se ve así:

/// A rectangle of eight-bit grayscale pixels.
 struct GrayscaleMap {
 pixels: Vec<u8>,
 size: (usize, usize)
 }

Esto declara un tipo GrayscaleMap con dos campos llamados píxeles y tamaño, del tipos dados. La convención en Rust es que todos los tipos, incluidas las estructuras, tengan nombres que escriben en mayúscula la primera letra de cada palabra, como GrayscaleMap, una convención llamada CamelCase (o PascalCase). Los campos y métodos están en minúsculas, con palabras separadas por guiones bajos. Esto se llama snake_case.

Puede construir un valor de este tipo con una expresión de estructura, como esta:

let width = 1024;
let height = 576;

let image = **GrayscaleMap** {
pixels: vec![0; width * height],
size: (width, height)
 };

Una expresión de estructura comienza con el nombre del tipo (GrayscaleMap) y enumera el nombre y valor de cada campo, todo encerrado entre llaves. También hay una abreviatura para poblar campos de variables locales o argumentos con el mismo nombre:

fn new_map(size: (usize, usize), pixels: Vec<u8>) -> GrayscaleMap {
	 assert_eq!(pixels.len(), size.0 * size.1);
	 **GrayscaleMap** **{ pixels, size }**
 }

La expresión de estructura GrayscaleMap { pixels, size } es la abreviatura de GrayscaleMap { pixels: pixels, size: size }. Puede usar key : value sintaxis para algunos campos y abreviatura de otros en la misma expresión de estructura.

Para acceder a los campos de una estructura, utilice el conocido operador punto ( . ):

assert_eq!(image.size, (1024, 576));
assert_eq!(image.pixels.len(), 1024 * 576);