• 文件分层

    文件分层

    模块可以分配到文件/目录的层次结构中。让我们将可见性小节例子
    的代码拆开分到多个文件中：

    1. $ tree .
    2. .
    3. |-- my
    4. |   |-- inaccessible.rs
    5. |   |-- mod.rs
    6. |   `-- nested.rs
    7. `-- split.rs

    在 split.rs 文件：

    1. // 此声明将会查找名为 `my.rs` 或 `my/mod.rs` 的文件，并将该文件的内容插入到
    2. // 此作用域名为 `my` 的模块里面。
    3. mod my;
    5. fn function() {
    6.     println!("called `function()`");
    7. }
    9. fn main() {
    10.     my::function();
    12.     function();
    14.     my::indirect_access();
    16.     my::nested::function();
    17. }

    在 my/mod.rs 文件：

    1. // 类似地，`mod inaccessible` 和 `mod nested` 将找到 `nested.rs` 和
    2. // `inaccessible.rs` 文件，并在它们各自的模块中插入它们的内容。
    3. mod inaccessible;
    4. pub mod nested;
    6. pub fn function() {
    7.     println!("called `my::function()`");
    8. }
    10. fn private_function() {
    11.     println!("called `my::private_function()`");
    12. }
    14. pub fn indirect_access() {
    15.     print!("called `my::indirect_access()`, that\n> ");
    17.     private_function();
    18. }

    在 my/nested.rs 文件：

    1. pub fn function() {
    2.     println!("called `my::nested::function()`");
    3. }
    5. #[allow(dead_code)]
    6. fn private_function() {
    7.     println!("called `my::nested::private_function()`");
    8. }

    在 my/inaccessible.rs 文件：

    1. #[allow(dead_code)]
    2. pub fn public_function() {
    3.     println!("called `my::inaccessible::public_function()`");
    4. }

    我们看到代码仍然正常运行，就和前面的一样：

    1. $ rustc split.rs && ./split
    2. called `my::function()`
    3. called `function()`
    4. called `my::indirect_access()`, that
    5. > called `my::private_function()`
    6. called `my::nested::function()`