Problemas al usar módulos en Rust - importar, restringir, conflictos

Publicado por Brisa
hace 1 año

¡Ey, programadores de Rust!

Estoy teniendo un problema al intentar importar módulos en Rust y me preguntaba si alguien podría ayudarme a encontrar una solución. Estoy trabajando en un proyecto bastante grande y quiero estructurar mi código en módulos para que sea más legible y mantenible. Pero por alguna razón, los módulos no se están importando correctamente y estoy obteniendo errores de compilación.

Aquí está mi estructura de directorios:

proyecto
├── main.rs
└── src
    ├── lib.rs
    └── modulo.rs

En main.rs, tengo el siguiente código:

mod modulo;

fn main() {
    modulo::saludar();
}

Y en src/modulo.rs, tengo el siguiente código:

pub fn saludar() {
    println!("¡Hola desde el módulo!");
}

Cuando intento compilar mi código, obtengo el siguiente error:

error[E0432]: unresolved import `modulo`
 --> main.rs:1:1
  |
1 | mod modulo;
  | ^^^^^^^^^^ no `modulo` in the root

Intenté varias cosas para solucionar este problema, pero ninguno de los métodos que encontré parece funcionar. Intenté usar use, pero obtuve un error similar. También intenté especificar la ruta completa del módulo usando mod src::modulo, pero eso no funcionó tampoco.

¿Alguien tiene alguna idea de cómo puedo resolver este problema de importación de módulos en Rust? ¿Hay algo que me esté perdiendo o haciendo mal?

¡Agradecería cualquier ayuda en esto!

Rust módulos importación

Compartir en

Respuesta de Gordon Shumway
hace 1 año

¡Hola Brisa!

Por lo que puedo ver en la estructura de tu proyecto y en los snippets de código que has compartido, el problema parece estar en la organización de tus archivos y la forma en que Rust maneja los módulos.

En Rust, todos los manejos de módulos relativos a tu crate son manejados por lib.rs o main.rs. Si tienes un archivo lib.rs, se espera que ese sea el punto de entrada para el manejo de módulos de tu biblioteca (crate). En el caso de main.rs, será el punto de entrada para un binario.

Dado que estás intentando importar modulo.rs desde main.rs, Rust esperará encontrar el archivo de módulo en la misma carpeta que main.rs. Sin embargo, está en la carpeta src. Vamos a reestructurar tu código para que funcione correctamente.

Primero, si modulo.rs está destinado a ser un módulo del binario principal y no parte de una biblioteca (crate), entonces deberías trasladar modulo.rs al mismo nivel que main.rs:

proyecto
├── main.rs
├── modulo.rs
└── src
    └── lib.rs

Tu código original en main.rs debería funcionar con esta nueva estructura. Pero, si tu intención es usar src/lib.rs para organizar tus módulos como parte de una biblioteca, entonces deberías declarar tus módulos en lib.rs y referenciarlos desde main.rs.

Para hacerlo, tu estructura de archivos se vería así:

proyecto
├── main.rs
└── src
    ├── lib.rs
    └── modulo.rs

En src/lib.rs, declararías tu módulo así:

pub mod modulo;

Luego, en main.rs, puedes importar el módulo utilizando use:

extern crate nombre_del_proyecto; // Asumiendo que `nombre_del_proyecto` es el nombre de tu crate

use nombre_del_proyecto::modulo;

fn main() {
    modulo::saludar();
}

Es importante asegurarse de que nombre_del_proyecto coincida con el nombre de tu crate, que es usualmente determinado por el nombre de tu archivo Cargo.toml.

Además, asegúrate de que en tu Cargo.toml esté bien configurado el punto de entrada binario y la librería, algo así:

[lib]
path = "src/lib.rs"

[[bin]]
name = "nombre_del_binario"
path = "main.rs"

Intenta hacer los cambios sugeridos y tu código debería compilar sin problemas. ¡Espero que esto te ayude a resolver tu problema con los módulos en Rust!