Làm cách nào để nhập từ mô-đun anh chị em?

Question

Trong src/lib.rs Tôi đã sau

extern crate opal_core; 

mod functions; 
mod context; 
mod shader; 

Sau đó, trong src/context.rs Tôi có một cái gì đó như thế này, mà cố gắng để nhập ký tự từ src/shader.rs:

use opal_core::shader::Stage; 
use opal_core::shader::Shader as ShaderTrait; 
use opal_core::GraphicsContext as GraphicsContextTrait; 

use functions::*; // this import works fine 
use shader::*; // this one doesn't 

pub struct GraphicsContext { 
    functions: Gl 
} 

fn shader_stage_to_int(stage: &Stage) -> u32 { 
    match stage { 
     &Stage::Vertex => VERTEX_SHADER, 
     &Stage::Geometry => GEOMETRY_SHADER, 
     &Stage::Fragment => FRAGMENT_SHADER, 
    } 
} 

impl GraphicsContextTrait for GraphicsContext { 

    /// Creates a shader object 
    fn create_shader(&self, stage: Stage, source: &str) -> Box<ShaderTrait> { 
     let id; 

     unsafe { 
      id = self.functions.CreateShader(shader_stage_to_int(&stage)); 
     } 

     let shader = Shader { 
      id: id, 
      stage: stage, 
      context: self 
     }; 

     Box::new(shader) 
    } 
} 

Vấn đề là rằng tuyên bố use shader::*; cung cấp cho các lỗi nhập chưa được giải quyết.

Tôi đã đọc tài liệu và họ nói rằng use báo cáo luôn luôn đi từ gốc của thùng hiện tại (opal_driver_gl) vì vậy tôi nghĩ shader::* nên nhập opal_driver_gl::shader::* nhưng dường như không làm như vậy. Tôi có cần sử dụng các từ khóa self hoặc super ở đây không?

Cảm ơn nếu bạn có thể trợ giúp.

Answer 1

Để nhập một mô-đun trên cùng cấp, làm như sau:

random_file_0.rs:

// Note how this is a public function. It has to be in order to be 
// usable from other files (in this case `random_file_1.rs`) 
pub fn do_something() -> bool { 
    true 
} 

random_file_1.rs:

use super::random_file_0; 

#[test] 
fn do_something_else() { 
    assert!(random_file_0::do_something()); 
} 

hoặc thay thế random_file_1.rs:

// This can be a public function, but does not have to be unless you 
// are using it somewhere else 
use ::random_file_0; 

#[test] 
fn do_something_else() { 
    assert!(random_file_0::do_something()); 
} 

lib.rs:

mod random_file_0; 
mod random_file_1; 

Xem liên kết này: Rust By Example để biết thêm thông tin và ví dụ. Nếu điều đó không hiệu quả, dưới đây là mã hiển thị:

fn function() { 
    println!("called `function()`"); 
} 

mod my { 
    pub fn indirect_call() { 
     // Let's access all the functions named `function` from this scope 
     print!("called `my::indirect_call()`, that\n> "); 

     // `my::function` can be called directly 
     function(); 

     { 
      // This will bind to the `cool::function` in the *crate* scope 
      // In this case the crate scope is the outermost scope 
      use cool::function as root_cool_function; 

      print!("> "); 
      root_cool_function(); 
     } 

     { 
      // `self` refers to the current module scope, in this case: `my` 
      use self::cool::function as my_cool_function; 

      print!("> "); 
      my_cool_function(); 
     } 

     { 
      // `super` refers to the parent scope, i.e. outside of the `my` 
      // module 
      use super::function as root_function; 

      print!("> "); 
      root_function(); 
     } 
    } 

    fn function() { 
     println!("called `my::function()`"); 
    } 

    mod cool { 
     pub fn function() { 
      println!("called `my::cool::function()`"); 
     } 
    } 
} 

mod cool { 
    pub fn function() { 
     println!("called `cool::function()`"); 
    } 
} 

fn main() { 
    my::indirect_call(); 
}