Error E0425 de Rust: cannot find value in this scope (nombre no encontrado)

El error E0425 significa que Rust buscó un nombre en un punto concreto de tu código y no lo encontró ahí. Es uno de los errores más comunes que existen, y casi siempre se arregla rápido: suele ser un error al escribir el nombre, una variable que vive dentro de otro bloque o una función a la que le falta la ruta de su módulo. Esta página forma parte de la guía de errores del compilador.

El mensaje de error

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

Este es el programa que lo produjo:

fn main() {
    let total_score = 42;
    println!("Final score: {}", total_scor);
}

Qué significa

Los ^^^^ señalan el nombre que Rust no encontró: total_scor, en la línea 3. “Cannot find value in this scope” quiere decir “no encuentro ningún valor con ese nombre en este ámbito (scope)”, es decir, desde el punto donde está esa línea. Rust revisó todas las variables, funciones e importaciones visibles en ese punto, y ninguna se llamaba así.

Lee también la línea help:. Aquí rustc encontró una variable con un nombre parecido (total_score) e incluso te marca con un + la letra que falta. Cuando veas “a local variable with a similar name exists” (existe una variable local con un nombre parecido), es un error de escritura.

Es como gritar “¡Jon!” en una sala cuando tu amigo se llama John. Está ahí mismo, pero nadie responde a “Jon”.

El mismo error también aparece como cannot find function ... in this scope (no se encuentra la función) cuando el nombre que falta es una función que llamas.

Por qué Rust hace esto

Rust decide, antes de ejecutar tu programa, a qué se refiere cada nombre. Una variable solo existe desde su línea let hasta la } que cierra el bloque donde se declaró. Ese es su ámbito. Fuera de esa zona, el nombre simplemente no existe.

Muchos lenguajes te dejarían seguir, y te enterarías más tarde. En JavaScript, un error de escritura puede crear sin avisar una variable global nueva o darte undefined. En Python obtendrías un NameError en tiempo de ejecución, quizá solo en ese camino del código que tus pruebas nunca recorren. Rust lo detecta al compilar, siempre.

Con las funciones pasa lo mismo gracias a los módulos: una función dentro de mod billing no es visible desde main hasta que escribes su ruta o la traes con use.

Cómo solucionarlo

Solución 1: Corrige cómo está escrito el nombre

Elige esta cuando la línea help: dice que existe un nombre parecido. Es, con diferencia, la causa más común. Además, en Rust los nombres distinguen mayúsculas y minúsculas: Total_score y total_score son nombres distintos.

fn main() {
    let total_score = 42;
    println!("Final score: {}", total_score);
}

Salida:

Final score: 42

▶ Pruébalo tú mismo

Solución 2: Declara la variable donde ambas partes puedan verla

Elige esta cuando la ayuda dice “the binding is available in a different scope in the same function” (la variable existe, pero en otro ámbito de la misma función). Creaste la variable dentro de un bucle o de un bloque if y luego la usaste después de la }. La versión con el error se ve así:

fn main() {
    let prices = [120, 300, 80];
    for price in prices {
        let with_tax = price + price / 10;
        println!("{with_tax}");
    }
    println!("Último precio con impuestos: {}", with_tax); // error[E0425]
}

with_tax se crea de nuevo en cada vuelta del bucle y se descarta en la } del bucle. Si necesitas un valor después del bucle, decláralo antes y actualízalo dentro:

fn main() {
    let prices = [120, 300, 80];
    let mut last_with_tax = 0;

    for price in prices {
        let with_tax = price + price / 10;
        println!("{with_tax}");
        last_with_tax = with_tax;
    }

    println!("Último precio con impuestos: {}", last_with_tax);
}

Salida:

132
330
88
Último precio con impuestos: 88

▶ Pruébalo tú mismo

La misma solución sirve si usaste una variable antes de su línea let. Rust lee de arriba abajo, así que basta con subir el let.

Solución 3: Escribe la ruta de la función o añade un use

Elige esta para cannot find function cuando la función vive en otro módulo. Rust muestra:

error[E0425]: cannot find function `total_with_tax` in this scope
 --> src/main.rs:8:17
  |
8 |     let total = total_with_tax(50.0);
  |                 ^^^^^^^^^^^^^^ not found in this scope
  |
help: consider importing this function
  |
1 + use crate::billing::total_with_tax;
  |

rustc no encuentra total_with_tax en main, pero sabe dónde está y te propone la línea use que la haría visible. Puedes llamarla con su ruta completa (billing::total_with_tax(50.0)) o añadir el use que sugiere rustc:

mod billing {
    pub fn total_with_tax(amount: f64) -> f64 {
        amount * 1.2
    }
}

use crate::billing::total_with_tax;

fn main() {
    let total = total_with_tax(50.0);
    println!("{total}");
}

Salida:

60

▶ Pruébalo tú mismo

La función también tiene que ser pub. Sin eso obtendrías otro error (E0603, “function is private”, la función es privada). En Módulos verás cómo funcionan las rutas y use.

Solución 4: Añade self. delante de un campo

Elige esta dentro de un método, cuando el nombre que falta es uno de los campos de tu struct. Si vienes de Java o C#, es natural escribir count y esperar que se refiera al campo. En Rust siempre escribes self.count. rustc te lo dice así: help: you might have meant to use the available field (quizá querías usar el campo disponible).

struct Counter {
    count: u32,
}

impl Counter {
    fn report(&self) {
        println!("Contador: {}", self.count);
    }
}

fn main() {
    let c = Counter { count: 3 };
    c.report();
}

Salida:

Contador: 3

▶ Pruébalo tú mismo

Dónde suele aparecer

• Una variable creada dentro de un if. if balance > 50 { let bonus = 10; } y luego println!("{}", bonus) falla, porque bonus desapareció en la }. Solución: haz que el if produzca el valor, let bonus = if balance > 50 { 10 } else { 0 };.

• Llamar a un constructor sin su tipo. let p = new("ferris"); da cannot find function `new` in this scope. Solución: new pertenece al tipo, así que escribe Player::new("ferris").

• Usar self en una función que no tiene el parámetro self. Es el primo cercano de E0425, E0424:

  error[E0424]: expected value, found module `self`
   --> src/main.rs:7:9
    |
  6 |     fn reset() {
    |        ----- this function doesn't have a `self` parameter
  7 |         self.count = 0;
    |         ^^^^ `self` value is a keyword only available in methods with a `self` parameter

  rustc te dice que reset no tiene parámetro self, y que self solo existe en métodos que lo reciben. Solución: añade un parámetro self. rustc sugiere &self, pero esta función modifica un campo, así que necesita fn reset(&mut self).

Errores relacionados

• E0599: no method found: el nombre que llamas como método no existe en ese tipo.
• E0382: use of moved value: la variable existe, pero su valor se movió a otro sitio.
• E0308: mismatched types: el nombre se encontró, pero tiene el tipo equivocado.
• E0277: trait bound not satisfied: a un tipo le falta un trait que algún código necesita.
• Todos los errores del compilador: la lista completa, con un breve resumen de cada uno.

Comprueba lo que aprendiste

Comprueba lo aprendido

1. rustc dice "help: a local variable with a similar name exists". ¿Cuál es la causa más probable?

La variable se movió Un error al escribir el nombre de la variable La variable es privada

2. Escribes let found = true; dentro de un bucle for y usas found después del bucle. ¿Por qué falla?

found solo existe hasta la } que cierra el bucle Los booleanos no se pueden usar en bucles Te faltó mut

3. Una función send vive en mod mailer. ¿Qué línea permite que main la llame como send()?

mod send; import mailer.send; use crate::mailer::send; (y send debe ser pub)

Puntuación: 0 / 3

Para leer más

• E0425 — Rust error codes index (en inglés): la explicación oficial, con más ejemplos.
• Bringing Paths into Scope with use — The Rust Book (en inglés): cómo use hace visibles las funciones de otros módulos. También existe una traducción al español de la comunidad del libro.
• Scope and Shadowing — Rust by Example (en inglés): ejemplos cortos de dónde nace y dónde muere una variable.
• Method Syntax — The Rust Book (en inglés): por qué los métodos usan self y cómo llegar a los campos a través de él.
• E0424 — Rust error codes index (en inglés): el error relacionado de usar self fuera de un método.