文件分层

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

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