文件分层

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

  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()`