Rust
मॉड्यूल

वाक्य - विन्यास

• mod modname ; // एक ही निर्देशिका में modname .rs या modname /mod.rs में मॉड्यूल के लिए खोजें
• mod modname { block }

मॉड्यूल का पेड़

फ़ाइलें:

- example.rs (root of our modules tree, generally named lib.rs or main.rs when using Cargo)
- first.rs
- second/
  - mod.rs
  - sub.rs

मॉड्यूल:

- example        -> example
  - first        -> example::first
  - second       -> example::second
    - sub        -> example::second::sub
  - third        -> example::third

example.rs

pub mod first;
pub mod second;
pub mod third {
    ...
}

मॉड्यूल second में घोषित किया जाना है example.rs अपने माता पिता के रूप है फ़ाइल example और नहीं, उदाहरण के लिए, first और इस प्रकार में घोषित नहीं किया जा सकता first.rs या एक ही निर्देशिका स्तर में एक और फ़ाइल

second/mod.rs

pub mod sub;

# [पथ] विशेषता

रुस्ट के #[path] विशेषता का उपयोग किसी विशेष मॉड्यूल की खोज के लिए पथ को निर्दिष्ट करने के लिए किया जा सकता है यदि यह मानक स्थान पर नहीं है। यह आम तौर पर हतोत्साहित किया जाता है , हालांकि, क्योंकि यह मॉड्यूल को पदानुक्रम को नाजुक बनाता है और फ़ाइल को पूरी तरह से अलग निर्देशिका में स्थानांतरित करके बिल्ड को तोड़ना आसान बनाता है।

#[path="../path/to/module.rs"]
mod module;

कोड में नाम बनाम 'उपयोग' नाम

use कथन में नामों का डबल-कोलोन सिंटैक्स कोड में कहीं और उपयोग किए गए नामों के समान दिखता है, लेकिन इन रास्तों का अर्थ अलग है।

डिफ़ॉल्ट रूप से use विवरण में नाम क्रेट रूट पर शुरू होते हुए, निरपेक्ष रूप से व्याख्या किए जाते हैं। कोड में कहीं और नाम वर्तमान मॉड्यूल के सापेक्ष हैं।

बयान:

use std::fs::File;

टोकरे की मुख्य फाइल के साथ-साथ मॉड्यूल में भी यही अर्थ है। दूसरी ओर, एक फ़ंक्शन नाम जैसे कि std::fs::File::open() केवल टोकरे की मुख्य फ़ाइल में रस्ट के मानक पुस्तकालय को संदर्भित करेगा, क्योंकि कोड में नाम वर्तमान मॉड्यूल के सापेक्ष व्याख्या किए गए हैं।

fn main() {
    std::fs::File::open("example"); // OK
}

mod my_module {
   fn my_fn() {
       // Error! It means my_module::std::fs::File::open()
       std::fs::File::open("example"); 

       // OK. `::` prefix makes it absolute 
       ::std::fs::File::open("example"); 

       // OK. `super::` reaches out to the parent module, where `std` is present
       super::std::fs::File::open("example"); 
   } 
}

std::… बनाने के लिए std::… नाम हर जगह उसी तरह का व्यवहार करते हैं, जिस टोकरे की जड़ में आप जोड़ सकते हैं:

use std;

इसके विपरीत, आप उन्हें self या super कीवर्ड के साथ प्रीफ़िक्स करके पथ के सापेक्ष use कर सकते हैं:

 use self::my_module::my_fn;

अभिभावक मॉड्यूल तक पहुँचना

कभी-कभी, यह आपके प्रोजेक्ट में पूर्ण पथ के साथ कुछ का use किए बिना कार्यों और संरचनाओं को अपेक्षाकृत आयात करने के लिए उपयोगी हो सकता है। इसे प्राप्त करने के लिए, आप मॉड्यूल super उपयोग कर सकते हैं, जैसे:

fn x() -> u8 {
    5
}

mod example {
    use super::x;

    fn foo() {
        println!("{}", x());
    }
}

अपने वर्तमान मॉड्यूल के 'दादा-दादी' तक पहुंचने के लिए आप कई बार super उपयोग कर सकते हैं, लेकिन यदि आप एक आयात में कई बार super उपयोग करते हैं, तो आपको पठनीयता के मुद्दों को पेश करने से सावधान रहना चाहिए।

निर्यात और दृश्यता

निर्देशिका संरचना:

yourproject/
    Cargo.lock
    Cargo.toml
    src/
        main.rs
        writer.rs

main.rs

// This is import from writer.rs
mod writer;

fn main() {
    // Call of imported write() function.
    writer::write()
    
    // BAD
    writer::open_file()
}

writer.rs

// This function WILL be exported.
pub fn write() {}

// This will NOT be exported.
fn open_file() {}

मूल कोड संगठन

आइए देखें कि हम कोड को कैसे व्यवस्थित कर सकते हैं, जब कोडबेस बड़ा हो रहा हो।

01. कार्य

fn main() {
  greet();
}

fn greet() {
  println!("Hello, world!");
}

02. मॉड्यूल - एक ही फ़ाइल में

fn main() {
  greet::hello();
}

mod greet {
  // By default, everything inside a module is private
  pub fn hello() { // So function has to be public to access from outside
    println!("Hello, world!");
  }
}

03. मॉड्यूल - एक ही निर्देशिका में एक अलग फ़ाइल में

जब कुछ कोड को नई फ़ाइल में ले जाते हैं, तो कोड को mod घोषणा में लपेटने की आवश्यकता नहीं होती है। फ़ाइल ही एक मॉड्यूल के रूप में कार्य करती है।

// ↳ main.rs
mod greet; // import greet module

fn main() {
  greet::hello();
}

// ↳ greet.rs
pub fn hello() { // function has to be public to access from outside
  println!("Hello, world!");
}

जब किसी कोड को किसी नई फ़ाइल में ले जाते हैं, यदि उस कोड को एक mod घोषणा से लपेटा गया है, तो वह फ़ाइल का एक उप मॉड्यूल होगा।

// ↳ main.rs
mod greet;

fn main() {
  greet::hello::greet();
}

// ↳ greet.rs
pub mod hello { // module has to be public to access from outside
  pub fn greet() { // function has to be public to access from outside
    println!("Hello, world!");
  }
}

04. मॉड्यूल - एक अलग निर्देशिका में एक अलग फ़ाइल में

जब एक अलग निर्देशिका में कुछ कोड को एक नई फ़ाइल में ले जाते हैं, तो निर्देशिका स्वयं एक मॉड्यूल के रूप में कार्य करती है। और मॉड्यूल रूट में mod.rs निर्देशिका मॉड्यूल का प्रवेश बिंदु है। उस निर्देशिका की अन्य सभी फाइलें, उस निर्देशिका के उप मॉड्यूल के रूप में कार्य करती हैं।

// ↳ main.rs
mod greet;

fn main() {
  greet::hello();
}

// ↳ greet/mod.rs
pub fn hello() {
  println!("Hello, world!");
}

जब आपके पास मॉड्यूल रूट में कई फाइलें हों,

// ↳ main.rs
mod greet;

fn main() {
  greet::hello_greet()
}

// ↳ greet/mod.rs
mod hello;

pub fn hello_greet() {
  hello::greet()
}

// ↳ greet/hello.rs
pub fn greet() {
  println!("Hello, world!");
}

05. मॉड्यूल - self साथ

fn main() {
  greet::call_hello();
}

mod greet {
  pub fn call_hello() { 
    self::hello();
  }

  fn hello() {
    println!("Hello, world!");
  }
}

06. मॉड्यूल - super साथ

1. जब आप किसी मॉड्यूल से रूट फ़ंक्शन को एक्सेस करना चाहते हैं,

fn main() {
  dash::call_hello();
}

fn hello() {
  println!("Hello, world!");
}

mod dash {
  pub fn call_hello() {
    super::hello();
  }
}

2. जब आप किसी फ़ंक्शन को नेस्टेड मॉड्यूल के अंदर से बाहरी / पैरेंट मॉड्यूल में एक्सेस करना चाहते हैं,

fn main() {
  outer::inner::call_hello();
}

mod outer {

  pub fn hello() {
    println!("Hello, world!");
  }

  mod inner {
    pub fn call_hello() {
      super::hello();
    }
  }

}

07. मॉड्यूल - use साथ

1. जब आप पूर्ण पथ को एक नए नाम से बांधना चाहते हैं,

use greet::hello::greet as greet_hello;

fn main() {
  greet_hello();
}

mod greet {
  pub mod hello {
    pub fn greet() {
      println!("Hello, world!");
    }
  }
}

2. जब आप टोकरा गुंजाइश स्तर सामग्री का उपयोग करना चाहते हैं

fn main() {
  user::hello();
}

mod greet {
  pub mod hello {
    pub fn greet() {
      println!("Hello, world!");
    }
  }
}

mod user {
  use greet::hello::greet as call_hello;

  pub fn hello() {
    call_hello();
  }
}