update appendix

src/SUMMARY.md

@@ -37,7 +37,7 @@
 
 ## 基本 Rust 技能
 
-- [使用包、Crate 和模块管理不断增长的项目](ch07-00-managing-growing-projects-with-packages-crates-and-modules.md)
+- [包、Crates 与模块](ch07-00-managing-growing-projects-with-packages-crates-and-modules.md)
   - [包和 Crate](ch07-01-packages-and-crates.md)
   - [定义模块来控制作用域与私有性](ch07-02-defining-modules-to-control-scope-and-privacy.md)
   - [引用模块树中项的路径](ch07-03-paths-for-referring-to-an-item-in-the-module-tree.md)
@@ -101,17 +101,17 @@
   - [共享状态并发](ch16-03-shared-state.md)
   - [使用 `Sync` 与 `Send` Traits 的可扩展并发](ch16-04-extensible-concurrency-sync-and-send.md)
 
-- [Async 和 await](ch17-00-async-await.md)
+- [异步编程基础：Async、Await、Future 与 Stream](ch17-00-async-await.md)
   - [Futures 和 async 语法](ch17-01-futures-and-syntax.md)
   - [并发与 async](ch17-02-concurrency-with-async.md)
   - [使用任意数量的 futures](ch17-03-more-futures.md)
-  - [流（Streams）](ch17-04-streams.md)
+  - [Stream：按顺序出现的 Future](ch17-04-streams.md)
   - [深入理解 async 相关的 traits](ch17-05-traits-for-async.md)
   - [future、任务和线程](ch17-06-futures-tasks-threads.md)
 
 - [面向对象编程特性](ch18-00-oop.md)
   - [面向对象语言的特征](ch18-01-what-is-oo.md)
-  - [顾及不同类型值的 trait 对象](ch18-02-trait-objects.md)
+  - [使用 trait object 来抽象出共享行为](ch18-02-trait-objects.md)
   - [面向对象设计模式的实现](ch18-03-oo-design-patterns.md)
 
 ## 高级主题
@@ -129,7 +129,7 @@
   - [宏](ch20-05-macros.md)
 
 - [最后的项目：构建多线程 web server](ch21-00-final-project-a-web-server.md)
-  - [建立单线程 web server](ch21-01-single-threaded.md)
+  - [构建单线程 web server](ch21-01-single-threaded.md)
   - [将单线程 server 变为多线程 server](ch21-02-multithreaded.md)
   - [优雅停机与清理](ch21-03-graceful-shutdown-and-cleanup.md)
 

src/appendix-00.md

@@ -1,6 +1,5 @@
 # 附录
 
-<!-- https://github.com/rust-lang/book/blob/main/src/appendix-00.md -->
+[appendix-00.md](https://github.com/rust-lang/book/blob/1fedfc4b96c2017f64ecfcf41a0a07e2e815f24f/src/appendix-00.md)
-<!-- commit 1fedfc4b96c2017f64ecfcf41a0a07e2e815f24f -->
 
-附录部分包含一些在你的 Rust 之旅中可能用到的参考资料。
+以下几节包含一些你在 Rust 学习之旅中可能会用到的参考资料。

src/appendix-01-keywords.md

@@ -1,10 +1,8 @@
 ## 附录 A：关键字
 
-<!-- https://github.com/rust-lang/book/blob/main/src/appendix-01-keywords.md -->
+[appendix-01-keywords.md](https://github.com/rust-lang/book/blob/c0f0135ed8056650d0b4b8ac3cffdb277c31f06a/src/appendix-01-keywords.md)
-<!-- commit 56ec353290429e6547109e88afea4de027b0f1a9 -->
 
-下面的列表包含 Rust 中正在使用或者将来会用到的关键字。因此，这些关键字不能被用作标识符（除了 “[原始标识符][raw-identifiers]” 部分介绍的原始标识符），这包括函数、变量、参数、结构体字段、模块、crate、常量、宏、静态值、属性、类型、trait 或生命周期
+下面的列表包含 Rust 语言当前使用中或为将来使用而保留的关键字。因此，它们不能被用作标识符（原始标识符除外，我们会在 [“原始标识符”][raw-identifiers] 一节中介绍）。_标识符_ 指的是函数、变量、参数、结构体字段、模块、crate、常量、宏、静态值、属性、类型、trait 或生命周期的名字。
-的名字。
 
 [raw-identifiers]: #原始标识符
 
@@ -79,6 +77,8 @@
 
 例如，`match` 是关键字。如果尝试编译如下使用 `match` 作为名字的函数：
 
+<span class="filename">文件名：src/main.rs</span>
+
 ```rust,ignore,does_not_compile
 fn match(needle: &str, haystack: &str) -> bool {
     haystack.contains(needle)
@@ -111,6 +111,6 @@ fn main() {
 
 此代码编译没有任何错误。注意 `r#` 前缀需同时用于函数名定义和 `main` 函数中的调用。
 
-原始标识符允许使用你选择的任何单词作为标识符，即使该单词恰好是保留关键字。这给予了我们更大的自由来选择名字，这样与其他语言交互式就不用考虑到关键字问题，在要交互的语言中这个名字不是关键字。此外，原始标识符允许你使用以不同于你的 crate 使用的 Rust 版本编写的库。比如，`try` 在 2015 edition 中不是关键字，而在 2018、2021 和 2024 edition 则是。所以如果用 2015 edition 编写的库中带有 `try` 函数，在 2018 edition 中调用时就需要使用原始标识符语法，在这里是 `r#try`。有关版本的更多信息，请参见[附录 E][appendix-e]。
+原始标识符允许你把任意单词用作标识符，即使这个单词恰好是保留关键字。这让我们在选择标识符名称时拥有更大的自由，也让我们能够与那些把这些词当作普通名称、而不是关键字的其他语言程序进行集成。此外，原始标识符还允许你使用采用不同 Rust edition 编写的库。例如，`try` 在 2015 edition 中不是关键字，但在 2018、2021 和 2024 edition 中是。如果你依赖的某个库使用 2015 edition 编写，并且其中有一个名为 `try` 的函数，那么在较新的 edition 中调用它时，就需要使用原始标识符语法，在这里就是 `r#try`。有关 edition 的更多信息，请参见[附录 E][appendix-e]。
 
 [appendix-e]: appendix-05-editions.html

src/appendix-02-operators.md

@@ -1,7 +1,6 @@
 ## 附录 B：运算符与符号
 
-<!-- https://github.com/rust-lang/book/blob/main/src/appendix-02-operators.md -->
+[appendix-02-operators.md](https://github.com/rust-lang/book/blob/799aa759e03d36dff11e920cf35ac38f496815ea/src/appendix-02-operators.md)
-<!-- commit 0833386eab8f37c60b8d80e05fabc4a97d0628ee -->
 
 该附录包含了 Rust 语法的词汇表，包括运算符以及其它符号，这些符号单独出现或出现在路径、泛型、trait bounds、宏、属性、注释、元组以及大括号上下文中。
 
@@ -89,7 +88,7 @@
 | `'...'` | 字符字面值 |
 | `b'...'` | ASCII 码字节字面值 |
 | <code>&vert;...&vert; expr</code> | 闭包 |
-| `!` | 离散函数的总是为空的类型 |
+| `!` | 发散函数使用的始终为空的底类型 |
 | `_` | “忽略” 模式绑定；也用于增强整型字面值的可读性 |
 
 表 B-3 展示了出现在从模块结构到项的路径上下文中的符号
@@ -99,7 +98,7 @@
 | 符号 | 解释 |
 |--------|-------------|
 | `ident::ident` | 命名空间路径 |
-| `::path` | 与 extern prelude 相对的路径，其他所有 crate 都以此为根（即一个包含 crate 名称的显式绝对路径） |
+| `::path` | 相对于 crate 根的路径（也就是说，一个显式的绝对路径） |
 | `self::path` | 与当前模块相对的路径（即一个显式相对路径）|
 | `super::path` | 与当前模块的父模块相对的路径 |
 | `type::ident`, `<type as trait>::ident` | 关联常量、函数以及类型 |

src/appendix-03-derivable-traits.md

@@ -1,7 +1,6 @@
 ## 附录 C：可派生的 trait
 
-<!-- https://github.com/rust-lang/book/blob/main/src/appendix-03-derivable-traits.md -->
+[appendix-03-derivable-traits.md](https://github.com/rust-lang/book/blob/042803ac0fc63e2cb62a4e3b7aaedec018c583f9/src/appendix-03-derivable-traits.md)
-<!-- commit 56ec353290429e6547109e88afea4de027b0f1a9 -->
 
 在本书的各个部分中，我们讨论了可应用于结构体和枚举定义的 `derive` 属性。`derive` 属性会在使用 `derive` 语法标记的类型上生成对应 trait 的默认实现的代码。
 
@@ -19,7 +18,7 @@
 
 一个无法被派生的 trait 的例子是为终端用户处理格式化的 `Display` 。你应该时常考虑使用合适的方法来为终端用户显示一个类型。终端用户应该看到类型的什么部分？他们会找出相关部分吗？对他们来说最相关的数据格式是什么样的？Rust 编译器没有这样的洞察力，因此无法为你提供合适的默认行为。
 
-本附录所提供的可派生 trait 列表并不全面：库可以为其自己的 trait 实现 `derive`，可以使用 `derive` 的 trait 列表事实上是无限的。实现 `derive` 涉及到过程宏的应用，这在第二十章的 [“宏”][macros] 一节中有介绍。
+本附录所提供的可派生 trait 列表并不全面：库也可以为它们自己的 trait 实现 `derive`，因此可以与 `derive` 搭配使用的 trait 列表实际上是开放的。实现 `derive` 需要用到过程宏，这在第二十章的 [“自定义 `derive` 宏”][custom-derive-macros] 一节中有介绍。
 
 ### 用于程序员输出的 `Debug`
 
@@ -92,4 +91,4 @@
 [creating-instances-from-other-instances-with-struct-update-syntax]: ch05-01-defining-structs.html#使用结构体更新语法创建实例
 [stack-only-data-copy]: ch04-01-what-is-ownership.html#只在栈上的数据拷贝
 [variables-and-data-interacting-with-clone]: ch04-01-what-is-ownership.html#使用克隆的变量与数据交互
-[macros]: ch20-05-macros.html#宏
+[custom-derive-macros]: ch20-05-macros.html#自定义-derive-宏

src/appendix-04-useful-development-tools.md

@@ -1,7 +1,6 @@
 ## 附录 D：实用开发工具
 
-<!-- https://github.com/rust-lang/book/blob/main/src/appendix-04-useful-development-tools.md -->
+[appendix-04-useful-development-tools.md](https://github.com/rust-lang/book/blob/7b2b4804c0bd9442805441d21a945e4dd37092b2/src/appendix-04-useful-development-tools.md)
-<!-- commit 56ec353290429e6547109e88afea4de027b0f1a9 -->
 
 在本附录中，我们将讨论 Rust 项目提供的一些有助于开发 Rust 代码的工具。我们将介绍自动格式化、快速应用警告修复、linter 以及与 IDE 的集成。
 
@@ -9,17 +8,7 @@
 
 `rustfmt` 工具根据社区代码风格格式化代码。很多项目使用 `rustfmt` 来避免编写 Rust 代码风格的争论：所有人都用这个工具格式化代码！
 
-安装 `rustfmt`：
+Rust 安装默认已包含 `rustfmt`，因此你的系统上应该已经有 `rustfmt` 和 `cargo-fmt` 这两个程序了。它们类似于 `rustc` 和 `cargo` 的关系：`rustfmt` 提供更细粒度的控制，而 `cargo-fmt` 则理解使用 Cargo 的项目约定。要格式化任意 Cargo 项目，请运行以下命令：
-
-Rust 安装默认已包含 rustfmt，因此你的系统上应该已经有 `rustfmt` 和 `cargo-fmt` 程序了。这两个命令类似于 `rustc` 和 `cargo`，其中 `rustfmt` 提供了更细粒度的控制，而 `cargo-fmt` 则理解使用 Cargo 的项目约定。要格式化任何 Cargo 项目，请输入以下命令：
-
-```sh
-$ cargo fmt
-```
-
-运行此命令会格式化当前 crate 中所有的 Rust 代码。这应该只会改变代码风格，而不是代码语义。
-
-该命令会为你提供 `rustfmt` 和 `cargo-fmt`，类似于 Rust 同时提供 `rustc` 和 `cargo`。要格式化任何 Cargo 项目，请执行以下命令：
 
 ```console
 $ cargo fmt
@@ -42,9 +31,7 @@ fn main() {
 }
 ```
 
-这里定义变量 `x` 为可变，但是我们从未修改它。Rust 会警告说：
+这里定义变量 `x` 为可变，但我们实际上从未修改它。Rust 会对此发出警告：
-
-这里调用了 `do_something` 函数 100 次，不过从未在 `for` 循环体中使用变量 `i`。Rust 会警告说：
 
 ```console
 $ cargo build
@@ -82,7 +69,7 @@ fn main() {
 
 变量 `x` 现在是不可变的了，警告也不再出现。
 
-`cargo fix` 命令可以用于在不同 Rust 版本间迁移代码。版本在[附录 E][editions]中介绍。
+你也可以用 `cargo fix` 在不同 Rust edition 之间迁移代码。edition 在[附录 E][editions]中介绍。
 
 ### 使用 Clippy 获取更多 lint
 
@@ -94,7 +81,7 @@ Clippy 工具是一组 lints 的集合，用于分析你的代码，帮助你捕
 $ cargo clippy
 ```
 
-例如，你编写了一个程序使用了数学常数，例如 pi，的一个近似值，如下所示，：
+例如，假设你写了一个程序，像下面这样使用某个数学常量的近似值，例如 pi：
 
 <span class="filename">文件名：src/main.rs</span>
 
@@ -138,12 +125,12 @@ fn main() {
 
 ### 使用 `rust-analyzer` 的 IDE 集成
 
-为了帮助 IDE 集成，Rust 社区建议使用 [`rust-analyzer`][rust-analyzer]。这个工具是一组以编译器为中心的实用程序，它实现了 [Language Server Protocol][lsp]，一个 IDE 与编程语言之间的通信规范。`rust-analyzer` 可以用于不同的客户端，比如 [Visual Studio Code 的 Rust analyzer 插件][vscode]。
+为了帮助 IDE 集成，Rust 社区建议使用 [`rust-analyzer`][rust-analyzer]。这个工具是一组以编译器为中心的实用程序，它实现了 [Language Server Protocol][lsp]，这是 IDE 与编程语言之间通信的一项规范。不同的客户端都可以使用 `rust-analyzer`，例如 [Visual Studio Code 的 Rust analyzer 插件][vscode]。
 
 [lsp]: http://langserver.org/
 [vscode]: https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer
 
-访问 `rust-analyzer` 项目的[主页][rust-analyzer]来了解如何安装它，然后为你的 IDE 安装 language server 支持。如此你的 IDE 便会获得如自动补全、跳转到定义和 inline error 之类的功能。
+访问 `rust-analyzer` 项目的[主页][rust-analyzer]获取安装说明，然后为你所使用的 IDE 安装相应的 language server 支持。这样一来，你的 IDE 就会获得自动补全、跳转到定义以及内联错误等能力。
 
 [rust-analyzer]: https://rust-analyzer.github.io
 [editions]: appendix-05-editions.html

src/appendix-05-editions.md

@@ -1,13 +1,12 @@
 ## 附录 E：版本
 
-<!-- https://github.com/rust-lang/book/blob/main/src/appendix-05-editions.md -->
+[appendix-05-editions.md](https://github.com/rust-lang/book/blob/555182e7f27ffb9761e18455f4d7eb42443a2954/src/appendix-05-editions.md)
-<!-- commit 56ec353290429e6547109e88afea4de027b0f1a9 -->
 
 早在第一章，我们见过 `cargo new` 在 *Cargo.toml* 中增加了一些有关 `edition` 的元数据。本附录将解释其意义！
 
 Rust 语言和编译器有一个为期六周的发布循环，这意味着用户会稳定得到新功能的更新。其他编程语言发布大更新但不甚频繁；Rust 选择更为频繁的发布小更新。一段时间之后，所有这些小更新会日积月累。不过随着小更新逐次的发布，或许很难回过头来感叹：“哇，从 Rust 1.10 到 Rust 1.31，Rust 的变化真大！”
 
-大约每两到三年，Rust 团队会生成一个新的 Rust **版本**（*edition*）。每一个版本会结合已经落地的功能，并提供一个清晰的带有完整更新文档和工具的功能包。新版本会作为常规的六周发布过程的一部分发布。
+大约每三年左右，Rust 团队会发布一个新的 Rust **版本**（*edition*）。每一个版本会把已经落地的特性整合成一个清晰的整体，并配套提供完全更新过的文档和工具。新版本会作为常规六周发布流程的一部分发布。
 
 新的版本对不同人群具有不同意义：
 
@@ -25,4 +24,6 @@ Rust 语言和编译器有一个为期六周的发布循环，这意味着用户
 
 有一点需要明确：大部分功能在所有版本中都能使用。开发者使用任何 Rust 版本将能继续接收最新稳定版的改进。然而在一些情况，主要是增加了新关键字的时候，则可能出现了只能用于新版本的功能。只需切换版本即可利用新版本的功能。
 
-请查看 [_Edition Guide_](https://rust-lang-nursery.github.io/edition-guide/) 了解更多细节，这是一个全面介绍不同版本之间差异的书籍，包括如何通过 `cargo fix` 自动将代码迁移到新版本。
+更多细节请参见 [_Edition Guide_][edition-guide]。这是一本完整的指南，列举了不同 edition 之间的差异，并说明了如何通过 `cargo fix` 自动将代码升级到新的 edition。
+
+[edition-guide]: https://doc.rust-lang.org/stable/edition-guide

src/appendix-06-translation.md

@@ -1,9 +1,8 @@
 ## 附录 F：本书译本
 
-<!-- https://github.com/rust-lang/book/blob/main/src/appendix-06-translation.md -->
+[appendix-06-translation.md](https://github.com/rust-lang/book/blob/6818718c6b3cabc1ef6b06b2272632e12462162d/src/appendix-06-translation.md)
-<!-- commit fd0c2e900711a9c9e4b0b440f9156d926d52d513 -->
 
-一些非英语语言的资源。多数仍在翻译中；请查阅[翻译标签][label]来帮助翻译，或者添加译本链接！
+这里列出的是一些非英语资源。大多数仍在进行中；如果你想帮忙，或者想告诉我们新的译本，请查看[翻译标签][label]！
 
 [label]: https://github.com/rust-lang/book/issues?q=is%3Aopen+is%3Aissue+label%3ATranslations
 
@@ -28,3 +27,7 @@
 - [हिंदी](https://github.com/venkatarun95/rust-book-hindi)
 - [ไทย](https://github.com/rust-lang-th/book-th)
 - [Danske](https://github.com/DanKHansen/book-dk)
+- [O'zbek](https://github.com/rust-lang-uz/book)
+- [Tiếng Việt](https://github.com/tuanemdev/rust-book-vn)
+- [Italiano](https://nixxo.github.io/rust-lang-book-it/)
+- [বাংলা](https://github.com/IsmailHosenIsmailJames/rust-book-bn)

src/appendix-07-nightly-rust.md

@@ -1,7 +1,6 @@
 ## 附录 G：Rust 是如何开发的与 “Nightly Rust”
 
-<!-- https://github.com/rust-lang/book/blob/main/src/appendix-07-nightly-rust.md -->
+[appendix-07-nightly-rust.md](https://github.com/rust-lang/book/blob/af415fc6c8a6823dfb4595074f27d5a3e9e2fe49/src/appendix-07-nightly-rust.md)
-<!-- commit 3a30e4c1fbe641afc066b3af9eb01dcdf5ed8b24 -->
 
 本附录介绍 Rust 是如何开发的以及这对你作为 Rust 开发者的影响。
 
@@ -13,7 +12,7 @@
 
 ### Choo, Choo! 发布通道和发布时刻表（Riding the Trains）
 
-Rust 开发运行于一个**发布时刻表**（_train schedule_）之上。也就是说，所有的开发工作都位于 Rust 仓库的 `master` 分支。发布采用 software release train 模型，其被用于思科 IOS 等其它软件项目。Rust 有三个**发布通道**（_release channel_）：
+Rust 开发运行于一个**发布时刻表**（_train schedule_）之上。也就是说，所有的开发工作都发生在 Rust 仓库的主分支上。发布采用 software release train 模型，它曾被 Cisco IOS 及其他软件项目采用。Rust 有三个**发布通道**（_release channel_）：
 
 - Nightly
 - Beta
@@ -21,13 +20,13 @@ Rust 开发运行于一个**发布时刻表**（_train schedule_）之上。也
 
 大部分 Rust 开发者主要采用稳定版通道，不过希望实验新功能的开发者可能会使用 nightly 或 beta 版。
 
-如下是一个开发和发布过程如何运转的例子：假设 Rust 团队正在进行 Rust 1.5 的发布工作。该版本发布于 2015 年 12 月，不过这里只是为了提供一个真实的版本。Rust 新增了一项功能：一个 `master` 分支的新提交。每天晚上，会产生一个新的 nightly 版本。每天都是发布版本的日子，而这些发布由发布基础设施自动完成。所以随着时间推移，发布轨迹看起来像这样，版本每晚一发：
+如下是一个开发和发布过程如何运转的例子：假设 Rust 团队正在进行 Rust 1.5 的发布工作。该版本发布于 2015 年 12 月，不过这里只是为了提供一个真实的版本号。Rust 新增了一项功能：一个新提交进入了主分支。每天晚上，都会产生一个新的 nightly 版本。每天都是发布日，而这些发布由发布基础设施自动完成。所以随着时间推移，发布轨迹看起来像这样，版本每晚一发：
 
 ```text
 nightly: * - - * - - *
 ```
 
-每六周时间，是准备发布新版本的时候了！Rust 仓库的 `beta` 分支会从用于 nightly 的 `master` 分支产生。现在，有了两个发布渠道：
+每六周时间，是准备发布新版本的时候了！Rust 仓库的 `beta` 分支会从 nightly 所使用的主分支分出。现在，有了两个发布渠道：
 
 ```text
 nightly: * - - * - - *
@@ -43,7 +42,7 @@ nightly: * - - * - - * - - * - - *
 beta:                *
 ```
 
-比如我们发现了一个回归缺陷。好消息是在这些回归缺陷流入稳定发布之前还有一些时间来测试 beta 版本！fix 被合并到 `master`，为此 nightly 版本得到了修复，接着这些 fix 将 backport 到 `beta` 分支，一个新的 beta 发布就产生了：
+比如我们发现了一个回归缺陷。好消息是，在这些回归缺陷流入稳定发布之前，我们还有一些时间来测试 beta 版本！修复会先应用到主分支，因此 nightly 版本先得到修复；然后再把修复回移植到 `beta` 分支，于是新的 beta 发布就产生了：
 
 ```text
 nightly: * - - * - - * - - * - - * - - *
@@ -83,7 +82,7 @@ Rust 项目仅对最近的稳定版本提供支持。当发布新稳定版本时
 
 ### 不稳定功能
 
-这个发布模型中另一个值得注意的地方：不稳定功能（unstable features）。Rust 使用一个被称为 “功能标记”（“feature flags”）的技术来确定给定版本的某个功能是否启用。如果新功能正在积极地开发中，其提交到了 `master`，因此会出现在 nightly 版中，不过会位于一个 **功能标记** 之后。作为用户，如果你希望尝试这个正在开发的功能，必须使用 nightly 版并在源码中使用合适的标记来开启。
+这个发布模型中另一个值得注意的地方：不稳定功能（unstable features）。Rust 使用一种叫做 **feature flags** 的技术来决定某个发布中启用了哪些功能。如果一个新功能仍在积极开发中，它会进入主分支，因此也会出现在 nightly 版本里，但会被放在某个 **功能标记** 之后。作为用户，如果你想尝试这个仍在开发中的功能，可以这么做，但你必须使用 nightly 版 Rust，并在源码中添加相应的标记来显式启用它。
 
 如果使用的是 beta 或稳定版 Rust，则不能使用任何功能标记。这是在新功能被宣布为永久稳定之前让大家提前实际使用它们的关键。这既满足了希望使用最尖端技术的同学，那些坚持稳定版的同学也知道其代码不会被破坏。这就是无停滞稳定。
 
@@ -91,13 +90,13 @@ Rust 项目仅对最近的稳定版本提供支持。当发布新稳定版本时
 
 ### Rustup 和 Rust Nightly 的职责
 
-Rustup 使得改变不同发布通道的 Rust 更为简单，其在全局或分项目的层次工作。其默认会安装稳定版 Rust。例如，为了安装 nightly：
+Rustup 使得在不同 Rust 发布通道之间切换变得很容易，无论是全局还是按项目都可以。默认情况下，你安装的是稳定版 Rust。例如，要安装 nightly：
 
 ```console
 $ rustup toolchain install nightly
 ```
 
-你会发现 `rustup` 也安装了所有的**工具链**（_toolchains_，Rust 和其相关组件）。如下是一位作者的 Windows 计算机上的例子：
+你也可以用 `rustup` 查看已经安装的所有**工具链**（_toolchains_，也就是 Rust 发布版本及其相关组件）。下面是一位作者的 Windows 电脑上的例子：
 
 ```powershell
 > rustup toolchain list
@@ -121,6 +120,6 @@ $ rustup override set nightly
 
 任何人都可以编写 RFC 来改进 Rust，同时这些 RFC 会被 Rust 团队评审和讨论，他们由很多不同分工的子团队组成。这里是 [Rust 官网上](https://www.rust-lang.org/governance) 所有团队的总列表，其包含了项目中每个领域的团队：语言设计、编译器实现、基础设施、文档等。各个团队会阅读相应的提议和评论，发表自己的意见，并最终达成接受或回绝功能的一致。
 
-如果功能被接受了，在 Rust 仓库会打开一个 issue，人们就可以实现它。实现功能的人当然可能不是最初提议功能的人！当实现完成后，其会合并到 `master` 分支并位于一个功能开关（feature gate）之后，正如 [“不稳定功能”](#不稳定功能) 部分所讨论的。
+如果功能被接受了，Rust 仓库里就会开一个 issue，然后就会有人去实现它。最终完成实现的人，很可能并不是最初提出这个功能的人！当实现准备好之后，它会合并到主分支，并被放在一个 feature gate 之后，正如 [“不稳定功能”](#不稳定功能) 一节所讨论的那样。
 
 在稍后的某个时间，一旦使用 nightly 版的 Rust 团队能够尝试这个功能了，团队成员会讨论这个功能，它如何在 nightly 中工作，并决定是否应该进入稳定版。如果决定继续推进，功能开关会移除，然后这个功能就被认为是稳定的了！乘着“发布列车”，最终在新的稳定版 Rust 中出现。

src/ch20-05-macros.md

@@ -98,7 +98,7 @@ pub fn some_name(input: TokenStream) -> TokenStream {
 
 让我们看看不同种类的程序宏。我们将从一个自定义的派生宏开始，然后解释使其他形式不同的小差异。
 
-### 如何编写自定义 `derive` 宏
+### 自定义 `derive` 宏
 
 让我们创建一个 `hello_macro` crate，其包含名为 `HelloMacro` 的 trait 和关联函数 `hello_macro`。不同于让用户为其每一个类型实现 `HelloMacro` trait，我们将会提供一个过程式宏以便用户可以使用 `#[derive(HelloMacro)]` 注解它们的类型来得到 `hello_macro` 函数的默认实现。该默认实现会打印 `Hello, Macro! My name is TypeName!`，其中 `TypeName` 为定义了 trait 的类型名。换言之，我们会创建一个 crate，使程序员能够写类似示例 20-37 中的代码。