Shadowing frente a mutabilidad, y las constantes

Rust ofrece dos formas de “cambiar” una variable que parecen equivalentes pero significan cosas opuestas: mutar un binding mut o volver a declararlo con let (shadowing). Elegir la correcta comunica intención. Y en el otro extremo del espectro están las constantes —const y static—, valores fijados en compilación cuya semántica de memoria conviene no confundir.

Shadowing: un binding nuevo con el mismo nombre

El shadowing consiste en declarar con let una variable cuyo nombre ya existe. No mutas nada: creas un binding completamente nuevo que oculta (shadows) al anterior. La diferencia crucial frente a mut es que el nuevo binding puede tener otro tipo:

fn main() {
    let espacios = "   ";           // &str
    let espacios = espacios.len();  // ahora usize: ¡tipo distinto!
    println!("{espacios}");
}

Esto es imposible con mut, porque mutar exige conservar el tipo:

fn main() {
    let mut espacios = "   ";
    espacios = espacios.len(); // error[E0308]: mismatched types (&str vs usize)
}

El patrón idiomático es transformar y estrechar un valor por etapas, reutilizando el nombre para no inventar entrada_raw, entrada_limpia, entrada_num:

fn main() {
    let entrada = "  42  ";            // &str crudo
    let entrada = entrada.trim();      // &str recortado
    let entrada: i32 = entrada.parse().unwrap(); // i32 final
    println!("{}", entrada + 1);
}

Shadowing frente a mut: qué comunica cada uno

Aunque a veces sean intercambiables, transmiten intenciones distintas, y elegir bien es parte de escribir Rust idiomático:

Regla mental: si te preguntas “¿es el mismo dato en otro momento?” usa mut; si es “¿un dato nuevo hecho a partir del viejo?” usa shadowing. Además, el shadowing te deja mantener el resultado inmutable tras la transformación, algo que mut no ofrece.

const: constantes evaluadas en compilación

Una const es un valor calculado en tiempo de compilación e insertado en línea allí donde se use. No tiene una posición fija en memoria: conceptualmente es un nombre para un valor, no una variable. Requiere anotación de tipo obligatoria y se nombra en SCREAMING_SNAKE_CASE:

const MAX_PUNTOS: u32 = 100_000;
const SEGUNDOS_POR_HORA: u32 = 60 * 60;   // se evalúa en compilación

fn main() {
    const LOCAL: f64 = 3.141_592_653_589_793;  // válida en cualquier ámbito
    println!("{MAX_PUNTOS} {SEGUNDOS_POR_HORA} {LOCAL}");
}

Sus propiedades definitorias: no admite mut (es constante por definición), su valor debe ser un constant expression evaluable por el compilador, y puede declararse en cualquier ámbito, incluido dentro de una función. Gracias a las const fn, incluso puedes calcular constantes con funciones evaluadas en compilación.

static: un único lugar en memoria con vida ’static

Una static también es un valor global, pero con una diferencia semántica esencial: ocupa una dirección de memoria fija y única durante toda la ejecución del programa. Tiene, por tanto, vida 'static, la más larga posible.

static SALUDO: &str = "Hola, mundo";   // una sola instancia en memoria

fn main() {
    println!("{SALUDO}");
    println!("{:p}", SALUDO.as_ptr());  // tiene dirección: es referenciable
}

La distinción práctica: usa const para valores puros que quieres que se inserten en línea (la mayoría de los casos); usa static cuando necesitas que exista un objeto con una dirección estable —por ejemplo, un buffer grande que no quieres duplicar, o datos que expones por FFI a C.