Definir structs: campos, tuplas y unidades

Un struct es la herramienta con la que Rust te deja nombrar y agrupar datos que van juntos. Pero bajo la sintaxis hay una idea de teoría de tipos: un struct es un tipo producto, la combinación de sus campos. Entender eso —y las tres formas que adopta— es el primer ladrillo del sistema de tipos que sostiene todo Rust.

Structs con campos nombrados

La forma canónica agrupa campos con nombre y tipo:

struct Usuario {
    nombre: String,
    email: String,
    activo: bool,
    inicios_sesion: u64,
}

let u = Usuario {
    nombre: String::from("Ada"),
    email: String::from("ada@example.com"),
    activo: true,
    inicios_sesion: 0,
};

println!("{}", u.email);

El nombre de cada campo hace la construcción independiente del orden: da igual en qué secuencia escribas los campos, porque los emparejas por nombre, no por posición. Para mutar un campo, la instancia entera debe ser mut —Rust no permite marcar campos individuales como mutables; la mutabilidad es una propiedad del binding, no del dato—:

let mut u = Usuario { /* ... */ };
u.activo = false;   // requiere que 'u' sea 'mut'

El atajo de campos y la actualización

Cuando una variable local ya se llama igual que el campo, el field init shorthand elimina la repetición:

fn construir(nombre: String, email: String) -> Usuario {
    Usuario {
        nombre,            // en vez de 'nombre: nombre'
        email,             // en vez de 'email: email'
        activo: true,
        inicios_sesion: 0,
    }
}

Y para crear una instancia que es casi igual a otra, la sintaxis de actualización ..otro toma el resto de campos de una instancia existente:

let u2 = Usuario {
    email: String::from("ada2@example.com"),
    ..u                // el resto de campos vienen de 'u'
};

Tuple structs: el patrón newtype

Cuando los nombres de campo no aportan nada pero sí quieres un tipo nuevo y distinto, usa un tuple struct: campos por posición, accesibles con .0, .1:

struct Punto(f64, f64);
struct Metros(f64);
struct Segundos(f64);

let p = Punto(3.0, 4.0);
println!("{}", p.0);      // 3.0

Metros y Segundos envuelven el mismo f64, pero son tipos incompatibles: pasar segundos donde se esperan metros es un error de compilación. Esto es el newtype pattern, y no cuesta ni un byte ni un ciclo en tiempo de ejecución.

Unit structs: tipos de tamaño cero

Un struct sin campos —un unit struct— no ocupa memoria: es un zero-sized type (ZST). Sirve como marcador o para colgar comportamiento de algo que no lleva datos:

struct SiempreValido;

let _ = SiempreValido;   // no reserva ni un byte