Variables, mutabilidad y tipos

Un mismo nombre, reglas distintas

En «Variables, funciones y control de flujo» viste let y mut con una metáfora sencilla, sin nombrar shadowing, tipos escalares con tamaño, ni tuplas o arrays. Aquí retomamos las mismas piezas con el vocabulario y el rigor que usarás en el resto del curso: qué tipo elige Rust por defecto, cuándo tienes que anotarlo tú, y qué diferencia real hay entre mutar un valor y rebindear un nombre.

Todo lo que sigue —de structs a iteradores— asume que distingues un let mut de un shadowing, y que reconoces los cuatro tipos escalares de Rust. Esta lección construye esa base con código que compila y se ejecuta, no solo con pseudocódigo.

Verás cinco estaciones: mutabilidad, shadowing, tipos escalares, tipos compuestos de tamaño fijo, e inferencia. Cada una termina con un ejemplo real que puedes ejecutar o editar.

ESTADO · attemptsvalor inicial: 3
REGLA · let mutel cambio queda declarado
RESULTADO · attempts actualizadosin mut, esto no compilaría

01 / 05LET · INMUTABLE POR DEFECTO

Toda variable es inmutable salvo que declares mut

let crea una variable inmutable por defecto: una vez le das un valor, el compilador no te deja reasignarla. Si el valor sí necesita cambiar —como un contador de intentos que baja en cada turno—, lo declaras con mut, una palabra que hace visible en el código que esa variable va a cambiar.

Toda variable es inmutable en Rust salvo que declares mut explícitamente.

lib.rsCompila↗

/// Starts with a fixed budget of attempts and consumes one.
#[must_use]
pub fn count_attempts(budget: i32) -> i32 {
    let mut attempts = budget;
    attempts -= 1;
    attempts
}

// Playground entry point for this example.
fn main() {
    println!("attempts left: {}", count_attempts(3));
}

Resultado

Reasignar sin mut no es un error de estilo: es un error de compilación.

lib.rsNo compila↗

fn main() {
    let count = 1;
    count = count + 1; // ERROR: cannot assign twice to immutable variable
    println!("{count}");
}

Resultado

El compilador dice (E0384)

cannot assign twice to immutable variable. El compilador señala la primera asignación y la reasignación que la rompe.

error[E0384]: cannot assign twice to immutable variable `count`
--> src/main.rs:3:5
|
2 |     let count = 1;
|         ----- first assignment to `count`
3 |     count = count + 1;
|     ^^^^^^^^^^^^^^^^^ cannot assign twice to immutable variable `count`
|
help: consider making this binding mutable
|
2 |     let mut count = 1;
|         +++

let puede reutilizar un nombre con un tipo distinto

Escribir let otra vez con el mismo nombre crea una variable nueva que oculta —hace shadowing— a la anterior. A diferencia de mut, que cambia el valor sin poder cambiar su tipo, shadowing puede introducir un tipo distinto en cada paso.

En este ejemplo, spaces empieza siendo un &str de tres espacios y termina siendo un usize, su longitud. El compilador no se queja porque cada let crea una variable independiente; solo el nombre se reutiliza.

lib.rsCompila↗

/// Rebinds `spaces` twice: first as `&str`, then as its length.
#[must_use]
pub fn gap_width() -> usize {
    let spaces = "   ";
    let spaces = spaces.len();
    spaces
}

// Playground entry point for this example.
fn main() {
    println!("gap width: {}", gap_width());
}

Resultado

Rust tiene cuatro tipos escalares: enteros, decimales, bool y char

Un tipo escalar representa un único valor. Rust tiene cuatro: enteros como i32 (con variantes de distinto tamaño, con y sin signo), decimales como f64 —la precisión por defecto—, bool (true o false) y char, un carácter Unicode. Cuando escribes un número sin anotar, i32 y f64 son los tipos que Rust elige por defecto.

Si una operación se sale del rango de su tipo, el build en modo debug entra en pánico; en modo release, el valor da la vuelta silenciosamente (wrapping). Por eso conviene elegir el tamaño con intención, no por costumbre, cuando el rango de valores importa.

lib.rsCompila↗

/// Returns one value of each scalar type covered in this lesson.
#[must_use]
pub fn describe_trip() -> (i32, f64, bool, char) {
    let distance_km: i32 = 42;
    let precise_km: f64 = 42.195;
    let completed: bool = true;
    let grade: char = 'A';
    (distance_km, precise_km, completed, grade)
}

// Playground entry point for this example.
fn main() {
    let (km, precise_km, completed, grade) = describe_trip();
    println!("{km} {precise_km} {completed} {grade}");
}

Resultado

Tuplas y arrays guardan varios valores en un tamaño fijo

Una tupla agrupa varios valores, incluso de tipos distintos, en un compuesto de tamaño fijo: checkpoint junta una distancia f64 y unos minutos u32. Para recuperar cada campo, la desestructuras con let y un patrón entre paréntesis.

Un array agrupa varios valores del mismo tipo, también con tamaño fijo, y accedes a cada posición con corchetes. Ni la tupla ni el array pueden crecer: una colección que cambia de tamaño es tarea de Vec, que verás más adelante.

lib.rsCompila↗

/// Destructures a checkpoint tuple and indexes a fixed-size array of splits.
#[must_use]
pub fn last_split() -> f64 {
    let checkpoint: (f64, u32) = (10.5, 52);
    let (distance_km, _minutes) = checkpoint;
    let splits: [f64; 3] = [5.0, distance_km, 21.1];
    splits[2]
}

// Playground entry point for this example.
fn main() {
    println!("last split: {} km", last_split());
}

Resultado

La inferencia de tipos tiene un límite: la ambigüedad

La mayor parte del tiempo, Rust infiere el tipo de una variable a partir de cómo la usas después, sin que anotes nada. Pero parse es genérico: puede convertir texto en cualquier tipo numérico, y si nada más en el programa fija cuál, el compilador se queda sin pistas.

lib.rsNo compila↗

fn main() {
    let laps = "3".parse().unwrap(); // ERROR: type annotations needed
    println!("{laps}");
}

Resultado

El compilador dice (E0284)

type annotations needed. parse es genérico y nada más en el programa fija el tipo de destino.

error[E0284]: type annotations needed
--> src/main.rs:2:9
|
2 |     let laps = "3".parse().unwrap();
|         ^^^^       ----- type must be known at this point
|
= note: cannot satisfy `<_ as FromStr>::Err == _`
help: consider giving `laps` an explicit type
|
2 |     let laps: /* Type */ = "3".parse().unwrap();
|             ++++++++++++

Anotar el destino, con : u32 o con parse::<u32>(), resuelve la ambigüedad. El resto de la expresión sigue infiriéndose como siempre.

lib.rsCompila↗

/// Parses a lap count. The `: u32` annotation resolves the ambiguity that
/// `parse` alone cannot: without it, the target integer type is unknown.
///
/// # Panics
///
/// Panics if `raw` is not a valid `u32`.
#[must_use]
pub fn parse_laps(raw: &str) -> u32 {
    let laps: u32 = raw.parse().expect("a valid number of laps");
    laps
}

// Playground entry point for this example.
fn main() {
    println!("laps: {}", parse_laps("3"));
}

Resultado

.forge-journey { height: auto !important; } .forge-journey__viewport { position: static !important; height: auto !important; display: block !important; } .forge-journey__stage { min-height: auto; overflow: visible; } .forge-journey__fallback { position: static !important; width: auto !important; height: auto !important; margin: 0 !important; clip: auto !important; overflow: visible !important; } .forge-journey__fallback-chapter[hidden] { display: block !important; margin-bottom: 2rem; } .forge-journey__panel { min-height: auto !important; } .forge-journey__chapter { position: static !important; opacity: 1 !important; visibility: visible !important; transform: none !important; border-bottom: 1px solid rgba(255,255,255,.12); } .forge-journey__panel-header, .forge-journey__controls { display: none !important; }

Qué cambia respecto a otros lenguajes

Lenguaje	Declaración por defecto	Cómo declaras que puede cambiar
JavaScript	`let` es mutable por defecto	No hace falta nada extra; `const` sí bloquea la reasignación
Python	Toda variable es reasignable	No existe una palabra clave para marcar una variable como inmutable
Rust	`let` es inmutable por defecto	Debes escribir `mut` explícitamente

La diferencia no es solo sintáctica: en Rust, “inmutable por defecto” significa que el compilador rechaza la reasignación antes de ejecutar nada, no que exista una convención que puedas ignorar.

Objetivo

Completa split_kilometers para que devuelva (kilometros_completos, metros_sobrantes) a partir de una distancia total en metros.

Implementa

Sustituye `todo!` por la división y el resto de `total_meters` entre 1000.

Calcula los kilómetros completos con `/` y los metros sobrantes con `%`, y devuélvelos como tupla.

/// Splits a total distance in meters into whole kilometers and the remaining meters.
pub fn split_kilometers(total_meters: u32) -> (u32, u32) {
    todo!("return (total_meters / 1000, total_meters % 1000)")
}

Comprueba

Ejecuta tres casos visibles y usa el diagnóstico para corregir el código.

Pruebas visibles

divide correctamente para distancias exactas y no exactas

Compilador—

Modifica el código antes de ejecutar las pruebas.

Ayuda

Consulta pistas progresivas o compara con la solución.

Solución comentadaSolución↗

/// Splits a total distance in meters into whole kilometers and the remaining meters.
#[must_use]
pub fn split_kilometers(total_meters: u32) -> (u32, u32) {
    let kilometers = total_meters / 1000;
    let remaining_meters = total_meters % 1000;

    (kilometers, remaining_meters)
}

// Playground entry point for this example.
fn main() {
    let (km, m) = split_kilometers(1500);
    println!("{km} {m}");
}

Resultado

Resumen

let crea variables inmutables por defecto; let mut declara explícitamente que una variable cambiará.
Shadowing rebina un nombre con un nuevo let y puede cambiar de tipo; mut cambia el valor sin poder cambiar su tipo.
Rust tiene cuatro tipos escalares: enteros (i32 por defecto), decimales (f64 por defecto), bool y char.
El desbordamiento de un entero produce panic en debug y wrapping en release.
Las tuplas agrupan tipos distintos y los arrays agrupan el mismo tipo; ambos tienen tamaño fijo.
El compilador infiere tipos casi siempre; cuando no puede decidir, como con parse, exige una anotación explícita.

Fuentes

The Rust Programming Languagech03-01–ch03-05 · Klabnik, Nichols, Krycho y la comunidad de Rust
The Cargo Booktypes/numeric-types · The Rust Project Developers
Rust by Exampleprimitives
Comprehensive Rustvariable_bindings/basic-syntax · Geisler y colaboradores (Google)

Variables, mutabilidad y tipos

Un mismo nombre, reglas distintas

Qué cambia respecto a otros lenguajes

Divide una distancia en kilómetros completos y metros sobrantes.

Implementa

Separar kilómetros y metros

Comprueba

Ayuda

Resumen

Fuentes