मैं एक भाई मॉड्यूल से कैसे आयात करूं?

Question

src/lib.rs में मैं निम्नलिखित है

extern crate opal_core; 

mod functions; 
mod context; 
mod shader; 

फिर src/context.rs में

मैं कुछ इस तरह है, जो 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) 
    } 
} 

समस्या है कि बयान use shader::*; त्रुटि देता है अनसुलझा आयात।

मैं डॉक्स पढ़ रहा था और उन्होंने कहा कि use बयान हमेशा वर्तमान टोकरा (opal_driver_gl) की जड़ से जाना इसलिए मैंने सोचा कि shader::*opal_driver_gl::shader::* आयात होते रहना चाहिए, लेकिन यह ऐसा करने के लिए प्रकट नहीं होता। क्या मुझे यहां self या super कीवर्ड का उपयोग करने की आवश्यकता है?

धन्यवाद अगर आप मदद कर सकते हैं।

Answer 1

एक ही स्तर पर एक मॉड्यूल आयात करने के लिए, निम्न करें:

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()); 
} 

या वैकल्पिक 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: अधिक जानकारी और उदाहरण के लिए Rust By Example:

mod random_file_0; 
mod random_file_1; 

यह लिंक देखें।

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(); 
}