Rust 提供了一套强大的模块（module）系统，可以将代码按层次分成多个逻辑单元（模块），并管理这些模块之间的可见性（公有（public）或私有（private））。
模块是项的集合，项可以是：函数，结构体，trait，impl 块，甚至其他模块。

可见性

模块中只有公有的（public）项可以从模块外的作用域访问。

在同一模块中，项可以访问其它项，即使它是私有的。
模块也可以嵌套。
嵌套模块的可见性遵循相同的规则。

模块机制消除了相同名字的项之间的歧义。 ``rust // 一个名为my_mod` 的模块 mod my_mod { // 模块也可以嵌套 pub mod nested {

  // 使用 `pub(in path)` 语法定义的函数只在给定的路径中可见。
  // `path` 必须是父模块（parent module）或祖先模块（ancestor module）
  pub(in my_mod) fn public_function_in_my_mod() {
      print!("called `my_mod::nested::public_function_in_my_mod()`, that\n > ");
      public_function_in_nested()
  }
  // 使用 `pub(self)` 语法定义的函数则只在当前模块中可见。
  pub(self) fn public_function_in_nested() {
      println!("called `my_mod::nested::public_function_in_nested");
  }
  // 使用 `pub(super)` 语法定义的函数只在父模块中可见。
  pub(super) fn public_function_in_super_mod() {
      println!("called my_mod::nested::public_function_in_super_mod");
  }

}

pub fn call_public_function_in_my_mod() {

  print!("called `my_mod::call_public_funcion_in_my_mod()`, that\n> ");
  nested::public_function_in_my_mod();
  print!("> ");
  nested::public_function_in_super_mod();

}

// pub(crate) 使得函数只在当前 crate 中可见 pub(crate) fn public_function_in_crate() {

  println!("called `my_mod::public_function_in_crate()");

} }

fn main() { // pub(crate) 项可以在同一个 crate 中的任何地方访问 my_mod::public_function_in_crate();

my_mod::call_public_function_in_my_mod();

}

<a name="nq93x"></a>
# 结构体的可见性
结构体的字段也是一个可见性的层次。意义是隐藏信息（即封装，encapsulation）。
```rust
mod my {
    // 一个公有的结构体，带有一个公有的字段（类型为泛型 `T`）
    pub struct OpenBox<T> {
        pub contents: T,
    }
    // 一个公有的结构体，带有一个私有的字段（类型为泛型 `T`）    
    #[allow(dead_code)]
    pub struct ClosedBox<T> {
        contents: T,
    }
    impl<T> ClosedBox<T> {
        // 一个公有的构造器方法
        pub fn new(contents: T) -> ClosedBox<T> {
            ClosedBox {
                contents: contents,
            }
        }
    }
}
fn main() {
    // 带有公有字段的公有结构体，可以像平常一样构造
    let open_box = my::OpenBox { contents: "public information" };
    // 并且它们的字段可以正常访问到。
    println!("The open box contains: {}", open_box.contents);
    // 带有私有字段的公有结构体不能使用字段名来构造。
    // 并且一个结构体中的私有字段不能访问到。
    // 不过带有私有字段的结构体可以使用公有的构造器来创建。
    let _closed_box = my::ClosedBox::new("classified information");
}

use 声明

use 声明可以将一个完整的路径绑定到一个新名字上，从而更容易访问。
use 绑定拥有局部作用域。

// 将 `deeply::nested::function` 路径绑定到 `other_function`。
use deeply::nested::function as other_function;
fn function() {
    println!("called `function()`");
}
mod deeply {
    pub mod nested {
        pub fn function() {
            println!("called `deeply::nested::function()`")
        }
    }
}
fn main() {
    // 更容易访问 `deeply::nested::funcion`
    other_function();
    println!("Entering block");
    {
        // 这和 `use deeply::nested::function as function` 等价。
        // 此 `function()` 将掩蔽外部的同名函数。
        use deeply::nested::function;
        function();
        // `use` 绑定拥有局部作用域。在这个例子中，`function()`
        // 的掩蔽只存在在这个代码块中。
        println!("Leaving block");
    }
    function();
}

super 和 self

可以在路径中使用 super 和 self 关键字，从而在访问项时消除歧义，防止不必要的路径硬编码。

self 关键字表示当前的模块作用域，可以访问当前的作用域中函数，也可以访问内部的另一个模块。
super 关键字表示父作用域。

文件分层

模块可以分配到文件/目录的层次结构中。
mod 根据 pub 表示可见性。

// 此声明将会查找名为 `my.rs` 或 `my/mod.rs` 的文件，并将该文件的内容放到
// 此作用域中一个名为 `my` 的模块里面。
mod my;

10. 模块

可见性

use 声明

super 和 self

文件分层