Cómo leer al compilador

Lee un error de tipos

fn add_one(number: i32) -> i32 {
    number + 1
}

fn main() {
    let result = add_one("3"); // ERROR: expected `i32`, found `&str`
    println!("{result}");
}

error[E0308]: mismatched types
--> src/main.rs:6:26
|
6 |     let result = add_one("3");
|                  ------- ^^^ expected `i32`, found `&str`
|                  |
|                  arguments to this function are incorrect
|
note: function defined here
--> src/main.rs:1:4
|
1 | fn add_one(number: i32) -> i32 {
|    ^^^^^^^ -----------

El mensaje señala dos sitios a la vez: dónde llamaste a la función con el tipo equivocado (^^^) y dónde se definió esa función (note:). Para arreglarlo, conviertes el valor al tipo correcto o cambias la firma; aquí faltaría parsear "3" a i32 antes de llamar a add_one.

Cuando el compilador te sugiere el nombre

fn main() {
    let energy = 4;
    println!("{energie}"); // ERROR: cannot find value `energie`
}

error[E0425]: cannot find value `energie` in this scope
--> src/main.rs:3:16
|
3 |     println!("{energie}");
|                ^^^^^^^
|
help: a local variable with a similar name exists
|
3 -     println!("{energie}");
3 +     println!("{energy}");
|

Aquí el help: no solo dice qué está mal, propone el arreglo exacto: borrar energie y escribir energy. Cuando rustc encuentra un nombre parecido declarado cerca, casi siempre lo sugiere así.

Un warning no te detiene

fn main() {
    let energy = 4;
    println!("still compiles");
}

warning: unused variable: `energy`
--> src/main.rs:2:9
|
2 |     let energy = 4;
|         ^^^^^^ help: if this is intentional, prefix it with an underscore: `_energy`
|
= note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default

cargo build/cargo run terminan igual: el binario se genera, se ejecuta, e imprime still compiles. El warning queda solo como aviso en la terminal, no como bloqueo.

Profundiza con rustc –explain

rustc --explain E0308

Cualquier código con forma E#### acepta este comando: imprime la misma explicación extendida que existe en el índice oficial de errores, pero sin conexión y sin salir de la terminal.

Qué no cubre esta lección

• No cubre los errores del borrow checker (E0502, E0499…): eso llega con el módulo de ownership.
• No repite los lints de Clippy, ya vistos en la lección de instalación: Clippy avisa de estilo e idiomatismo, rustc de si el programa es válido.
• No explica cómo tu editor muestra estos mismos diagnósticos subrayados en vivo: eso es rust-analyzer, también visto antes.

Qué sigue

Con la capacidad de leer un error y saber qué mirar, el siguiente bloque del temario entra en la sintaxis real de Rust: variables, tipos, expresiones y funciones, la base sobre la que vas a escribir cada programa a partir de ahora.