包和模块
包（crate）
Rust 中，crate 是一个独立的可编译单元。具体说来，就是一个或一批文件（如果是一批文件，那么有一个文件是这个 crate 的入口）。它编译后，会对应着生成一个可执行文件或一个库。
执行 cargo new foo，会得到如下目录层级：
foo
├── Cargo.toml
└── src
└── lib.rs
这里，lib.rs 就是一个 crate（入口），它编译后是一个库。一个工程下可以包含不止一个 crate，本工程只有一个。
执行 cargo new --bin bar，会得到如下目录层级：
bar
├── Cargo.toml
└── src
└── main.rs
这里，main.rs 就是一个 crate（入口），它编译后是一个可执行文件。
模块（module）
Rust 提供了一个关键字 mod，它可以在一个文件中定义一个模块，或者引用另外一个文件中的模块。
关于模块的一些要点：
- 每个 crate 中，默认实现了一个隐式的
根模块（root module）； - 模块的命名风格也是
lower_snake_case，跟其它的 Rust 的标识符一样； - 模块可以嵌套；
- 模块中可以写任何合法的 Rust 代码；
在文件中定义一个模块
比如，在上述 lib.rs 中，我们写上如下代码：
mod aaa {
const X: i32 = 10;
fn print_aaa() {
println!("{}", 42);
}
}
我们可以继续写如下代码：
mod aaa {
const X: i32 = 10;
fn print_aaa() {
println!("{}", 42);
}
mod BBB {
fn print_bbb() {
println!("{}", 37);
}
}
}
还可以继续写：
mod aaa {
const X: i32 = 10;
fn print_aaa() {
println!("{}", 42);
}
mod bbb {
fn print_bbb() {
println!("{}", 37);
}
}
}
mod ccc {
fn print_ccc() {
println!("{}", 25);
}
}
模块的可见性
我们前面写了一些模块，但实际上，我们写那些模块，目前是没有什么作用的。写模块的目的一是为了分隔逻辑块，二是为了提供适当的函数，或对象，供外部访问。而模块中的内容，默认是私有的，只有模块内部能访问。
为了让外部能使用模块中 item，需要使用 pub 关键字。外部引用的时候，使用 use 关键字。例如：
mod ccc {
pub fn print_ccc() {
println!("{}", 25);
}
}
fn main() {
use ccc::print_ccc;
print_ccc();
// 或者
ccc::print_ccc();
}
规则很简单，一个 item（函数，绑定，Trait 等），前面加了 pub，那么就它变成对外可见（访问，调用）的了。
引用外部文件模块
通常，我们会在单独的文件中写模块内容，然后使用 mod 关键字来加载那个文件作为我们的模块。
比如，我们在 src 下新建了文件 aaa.rs。现在目录结构是下面这样子：
foo
├── Cargo.toml
└── src
└── aaa.rs
└── main.rs
我们在 aaa.rs 中，写上：
pub fn print_aaa() {
println!("{}", 25);
}
在 main.rs 中，写上：
mod aaa;
use aaa::print_aaa;
fn main () {
print_aaa();
}
编译后，生成一个可执行文件。
细心的朋友会发现，aaa.rs 中，没有使用 mod xxx {} 这样包裹起来，是因为 mod xxx; 相当于把 xxx.rs 文件用 mod xxx {} 包裹起来了。初学者往往会多加一层，请注意。
多文件模块的层级关系
Rust 的模块支持层级结构，但这种层级结构本身与文件系统目录的层级结构是解耦的。
mod xxx; 这个 xxx 不能包含 :: 号。也即在这个表达形式中，是没法引用多层结构下的模块的。也即，你不可能直接使用 mod a::b::c::d; 的形式来引用 a/b/c/d.rs 这个模块。
那么，Rust 的多层模块遵循如下两条规则：
mod xxx;默认优先查找，同级目录下的xxx.rs文件；- 如果
xxx.rs不存在，则查找xxx/mod.rs文件，即xxx目录下的mod.rs文件。
上述两种情况，加载成模块后，效果是相同的。Rust 就凭这两条规则，通过迭代使用，结合 pub 关键字，实现了对深层目录下模块的加载；
下面举个例子，现在我们建了一个测试工程，目录结构如下：
src
├── a
│ ├── b
│ │ ├── c
│ │ │ ├── d.rs
│ │ │ └── mod.rs
│ │ └── mod.rs
│ └── mod.rs
└── main.rs
a/b/c/d.rs 文件内容：
pub fn print_ddd() {
println!("i am ddd.");
}
a/b/c/mod.rs 文件内容：
pub mod d;
a/b/mod.rs 文件内容：
pub mod c;
a/mod.rs 文件内容：
pub mod b;
main.rs 文件内容：
mod a;
use a::b::c::d;
fn main() {
d::print_ddd();
}
输出结果为：i am ddd.
仔细理解本例子，就明白 Rust 的层级结构模块的用法了。
至于为何 Rust 要这样设计，有几下几个原因：
- Rust 本身模块的设计是与操作系统文件系统目录解耦的，因为 Rust 本身可用于操作系统的开发；
- Rust 中的一个文件内，可包含多个模块，直接将
a::b::c::d映射到a/b/c/d.rs会引起一些歧义； - Rust 一切从安全性、显式化立场出发，要求引用路径中的每一个节点，都是一个有效的模块，比如上例，
d是一个有效的模块的话，那么，要求c, b, a分别都是有效的模块，可单独引用。
路径
前面我们提到，一个 crate 是一个独立的可编译单元。它有一个入口文件，这个入口文件是这个 crate（里面可能包含若干个 module）的模块根路径。整个模块的引用，形成一个链，每个模块，都可以用一个精确的路径（比如：a::b::c::d）来表示；
与文件系统概念类似，模块路径也有相对路径和绝对路径的概念。为此，Rust 提供了 self 和 super 两个关键字。
self 在路径中，有两种意思：
use self::xxx表示，加载当前模块中的xxx。此时 self 可省略；use xxx::{self, yyy}，表示，加载当前路径下模块xxx本身，以及模块xxx下的yyy；
super 表示，当前模块路径的上一级路径，可以理解成父模块。
use super::xxx;
表示引用父模块中的 xxx。
另外，还有一种特殊的路径形式：
::xxx::yyy
它表示，引用根路径下的 xxx::yyy，这个根路径，指的是当前 crate 的根路径。
路径中的 * 符号：
use xxx:*
表示导入 xxx 模块下的所有可见 item（加了 pub 标识的 item）。
Re-exporting
我们可以结合使用 pub use 来实现 Re-exporting。Re-exporting 的字面意思就是 重新导出。它的意思是这样的，把深层的 item 导出到上层目录中，使调用的时候，更方便。接口设计中会大量用到这个技术。
还是举上面那个 a::b::c::d 的例子。我们在 main.rs 中，要调用 d，得使用 use a::b::c::d; 来调用。而如果我们修改 a/mod.rs 文件为：
a/mod.rs 文件内容：
pub mod b;
pub use b::c::d;
那么，我们在 main.rs 中，就可以使用 use a::d; 来调用了。从这个例子来看没觉得方便多少。但是如果开发的一个库中有大量的内容，而且是在不同层次的模块中。那么，通过统一导出到一个地方，就能大大方便接口使用者。
加载外部 crate
前面我们讲的，都是在当前 crate 中的技术。真正我们在开发时，会大量用到外部库。外部库是通过
extern crate xxx;
这样来引入的。
注：要使上述引用生效，还必须在 Cargo.toml 的 dependecies 段，加上 xxx="version num" 这种依赖说明，详情见 Cargo 项目管理 这一章。
引入后，就相当于引入了一个符号 xxx，后面可以直接以这个 xxx 为根引用这个 crate 中的 item：
extern crate xxx;
use xxx::yyy::zzz;
引入的时候，可以通过 as 关键字重命名。
extern crate xxx as foo;
use foo::yyy::zzz;