module - ps4 - ¿Cómo hago una importación/inclusión básica de una función de un módulo a otro en Rust 2015?

rust traduccion

Question

No puedo encontrar cómo incluir (o importar, inyectar o alguna otra palabra) una función de un archivo (módulo) a otro.

Comienzo un nuevo proyecto con

$ cd ~/projects
$ cargo new proj --bin
$ cd proj
$ tree
.
|
-- Cargo.toml
-- src
   |
   -- main.rs

main.rs y creo un nuevo archivo a.rs (dentro del directorio src ) con el siguiente código:

main.rs

fn main() {
    println!("{}", a::foo());
}

a.rs

pub fn foo() -> i32 { 42 }

Ejecuto el proyecto con cargo run y obtengo el error:

error[E0433]: failed to resolve: use of undeclared type or module `a`
 --> src/main.rs:2:20
  |
2 |     println!("{}", a::foo());
  |                    ^ use of undeclared type or module `a`

Parece que necesito importar el a alguna manera. Intenté agregar las siguientes cosas como primera línea a main.rs

• use a;

  error[E0432]: unresolved import `a`
   --> src/main.rs:1:5
    |
  1 | use a;
    |     ^ no `a` in the root

• use a::*;

  error[E0432]: unresolved import `a`
   --> src/main.rs:1:5
    |
  1 | use a::*;
    |     ^ maybe a missing `extern crate a;`?
  
  error[E0433]: failed to resolve: use of undeclared type or module `a`
   --> src/main.rs:4:20
    |
  4 |     println!("{}", a::foo());
    |                    ^ use of undeclared type or module `a`

• use a::foo;

  error[E0432]: unresolved import `a`
   --> src/main.rs:1:5
    |
  1 | use a::foo;
    |     ^ maybe a missing `extern crate a;`?
  
  error[E0433]: failed to resolve: use of undeclared type or module `a`
   --> src/main.rs:4:20
    |
  4 |     println!("{}", a::foo());
    |                    ^ use of undeclared type or module `a`

• extern crate a; use a::foo;

  error[E0463]: can''t find crate for `a`
   --> src/main.rs:1:1
    |
  1 | extern crate a;
    | ^^^^^^^^^^^^^^^ can''t find crate

• extern crate proj; use proj::a::foo;

  error[E0463]: can''t find crate for `proj`
   --> src/main.rs:1:1
    |
  1 | extern crate proj;
    | ^^^^^^^^^^^^^^^^^^ can''t find crate

He leído la guía pero todavía no puedo entender cómo hacer importaciones.

Answer 1

En Rust, hay algunas palabras clave para tratar con módulos:

extern crate

extern crate llena el espacio entre Cargo y Rust. Escribimos código en un archivo .rs, este archivo se puede compilar con rustc . Cargo gestionará las dependencias externas y llamará a rustc . La línea de extern crate ... le dice al compilador que busque este espacio de nombres, por lo que no es ambiguo.

Nota del editor: la extern crate no es necesaria en muchos casos si está utilizando la edición Rust 2018.

mod

mod tiene dos usos:

• cuando se usa con llaves, declara un módulo (espacio de nombres).
• cuando se usa solo con un nombre, buscará el módulo en el sistema de archivos local.

Los módulos pueden ser:

• archivos con extensión .rs
• carpetas con un archivo llamado mod.rs

use

use importa un espacio de nombres. Estamos obligados a anunciar qué vamos a usar antes de usarlo. La cláusula de uso es bastante estricta, si use module1::moduleA; Ningún otro módulo del module1 estará disponible excepto el moduleA Se puede usar un asterisco ( * ) para usar todo dentro de un módulo: use module1::*; . Los conjuntos también se pueden usar: use module1::{moduleA, moduleB};

Un ejemplo:

| main.rs
|- module1
      |- mod.rs
      |- moduleA.rs
      |- moduleB.rs

mod.rs contiene:

pub mod moduleA; // declare a child module
pub mod moduleB; // declare a child module

main.rs contiene:

///  ======
// use what Cargo downloaded
extern crate that_one_thing_i_need;

///  ======

mod module1; // declare a child module

// some local stuff I want to scope
mod local {
    pub fn my_function() {}
}

//   ======

// make the symbols locally available:
use module1::moduleA::*;
use module1::moduleB::{functionX, moduleY, typeZ};

// we still need to announce what stuff from the external crate
// we want to use:
// We can do local aliases that will be valid in this one file.
use that_one_thing_i_need::fancy_stuff as fs;

///  ======

fn main() {
    // we can use anything here from the namespaces we are using:
    //      moduleA
    //      functionX
    //      moduleY
    //      typeZ
    //      fs

    // We can access stuff by navigating from the outermost visible
    // module name
    local::my_function();
}

Los símbolos solo se pueden usar desde el módulo. Si desea cruzar esta barrera (incluso en un módulo declarado localmente), debemos hacerlos públicos utilizando la palabra clave pub .

Answer 2

En un módulo principal (main.rs, lib.rs o subdir / mod.rs), debe escribir mod a; para todos los demás módulos que desea utilizar en todo su proyecto (o en el subdirectorio).

En cualquier otro módulo, necesita escribir use a; o use a::foo;

Estás lejos de ser la única persona confundida por esto, y ciertamente es posible hacerlo mejor, pero cualquier cambio en el sistema del módulo será rechazado por ser "demasiado confuso".

Editar: esta respuesta fue escrita para el lenguaje estándar "Rust 2015". Se hicieron cambios para el estándar "Rust 2018", vea esta publicación de blog y la guía de edición