fix typo: remove necessary character for macro, std, mod, meta (#161)

Co-authored-by: YangFong <[email protected]>

Author: Kalmaegi

src/macros/designators.md

@@ -1,7 +1,6 @@
 # 指示符
 
-宏的参数使用一个美元符号 `$` 作为前缀，并使用一个**指示符**（designator）来
-注明类型：
+宏的参数使用一个美元符号 `$` 作为前缀，并使用一个**指示符**（designator）来注明类型：
 
 ```rust,editable
 macro_rules! create_function {

src/macros/dry.md

@@ -1,8 +1,6 @@
 # DRY (不写重复代码)
 
-通过提取函数或测试集的公共部分，宏可以让你写出 DRY 的代码（DRY 是 Don't Repeat
-Yourself 的缩写，意思为 “不要写重复代码”）。这里给出一个例子，对 `Vec<T>` 实现
-并测试了关于 `+=`、`*=` 和 `-=` 等运算符。
+通过提取函数或测试集的公共部分，宏可以让你写出 DRY 的代码（DRY 是 Don't Repeat Yourself 的缩写，意思为 “不要写重复代码”）。这里给出一个例子，对 `Vec<T>` 实现并测试了关于 `+=`、`*=` 和 `-=` 等运算符。
 
 ```rust,editable
 use std::ops::{Add, Mul, Sub};

src/macros/dsl.md

@@ -1,8 +1,6 @@
 # DSL（领域专用语言）
 
-DSL 是 Rust 的宏中集成的微型 “语言”。这种语言是完全合法的，因为宏系统会把它转换
-成普通的 Rust 语法树，它只不过看起来像是另一种语言而已。这就允许你为一些特定功能
-创造一套简洁直观的语法（当然是有限制的）。
+DSL 是 Rust 的宏中集成的微型 “语言”。这种语言是完全合法的，因为宏系统会把它转换成普通的 Rust 语法树，它只不过看起来像是另一种语言而已。这就允许你为一些特定功能创造一套简洁直观的语法（当然是有限制的）。
 
 比如说我想要定义一套小的计算器 API，可以传给它表达式，它会把结果打印到控制台上。
 

src/macros/overload.md

@@ -1,7 +1,6 @@
 # 重载
 
-宏可以重载，从而接受不同的参数组合。在这方面，`macro_rules!` 的作用类似于
-匹配（match）代码块：
+宏可以重载，从而接受不同的参数组合。在这方面，`macro_rules!` 的作用类似于匹配（match）代码块：
 
 ```rust,editable
 // 根据你调用它的方式，`test!` 将以不同的方式来比较 `$left` 和 `$right`。

src/macros/repeat.md

@@ -1,10 +1,8 @@
 # 重复
 
-宏在参数列表中可以使用 `+` 来表示一个参数可能出现一次或多次，使用 `*` 来表示该
-参数可能出现零次或多次。
+宏在参数列表中可以使用 `+` 来表示一个参数可能出现一次或多次，使用 `*` 来表示该参数可能出现零次或多次。
 
-在下面例子中，把模式这样： `$(...),+` 包围起来，就可以匹配一个或多个用逗号隔开
-的表达式。另外注意到，宏定义的最后一个分支可以不用分号作为结束。
+在下面例子中，把模式这样： `$(...),+` 包围起来，就可以匹配一个或多个用逗号隔开的表达式。另外注意到，宏定义的最后一个分支可以不用分号作为结束。
 
 ```rust,editable
 // `min!` 将求出任意数量的参数的最小值。

src/macros/variadics.md

@@ -1,7 +1,6 @@
 # 可变参数接口
 
-可变参数接口可以接受任意数目的参数。比如说 `println` 就可以，其参数的数目是由
-格式化字符串指定的。
+可变参数接口可以接受任意数目的参数。比如说 `println` 就可以，其参数的数目是由格式化字符串指定的。
 
 我们可以把之前的 `calculate!` 宏改写成可变参数接口：
 

src/meta/doc.md

@@ -8,8 +8,7 @@
 
 ## 文档注释
 
-文档注释对于需要文档的大型项目来说非常重要。当运行 `rustdoc`，文档注释就会
-编译成文档。它们使用 `///` 标记，并支持 [Markdown]。
+文档注释对于需要文档的大型项目来说非常重要。当运行 `rustdoc`，文档注释就会编译成文档。它们使用 `///` 标记，并支持 [Markdown]。
 
 ```rust,editable,ignore
 #![crate_name = "doc"]
@@ -55,8 +54,7 @@ fn main() {
 }
 ```
 
-要运行测试，首先将代码构建为库，然后告诉 `rustdoc` 在哪里找到库，这样它就可以
-使每个文档中的程序链接到库：
+要运行测试，首先将代码构建为库，然后告诉 `rustdoc` 在哪里找到库，这样它就可以使每个文档中的程序链接到库：
 
 ```shell
 $ rustc doc.rs --crate-type lib
@@ -102,7 +100,7 @@ pub use crate::mem::drop;
 pub use self::async_await::*;
 ```
 
-对文档来说， `rustdoc` 被社区广泛采用。[标准库文档](https://doc.rust-lang.org/std/)也是用它生成的。
+对文档来说，`rustdoc` 被社区广泛采用。[标准库文档](https://doc.rust-lang.org/std/)也是用它生成的。
 
 ### 参见:
 

src/mod.md

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

src/mod/split.md

@@ -1,7 +1,6 @@
 # 文件分层
 
-模块可以分配到文件/目录的层次结构中。让我们将《可见性》一节中
-的[例子][visibility]的代码拆分到多个文件中：
+模块可以分配到文件/目录的层次结构中。让我们将《可见性》一节中的[例子][visibility]的代码拆分到多个文件中：
 
 ```bash
 $ tree .

src/mod/struct_visibility.md

@@ -1,8 +1,6 @@
 # 结构体的可见性
 
-结构体的字段也是一个可见性的层次。字段默认拥有私有的可见性，也可以加上 `pub` 修
-饰语来重载该行为。只有从结构体被定义的模块之外访问其字段时，这个可见性才会
-起作用，其意义是隐藏信息（即封装，encapsulation）。
+结构体的字段也是一个可见性的层次。字段默认拥有私有的可见性，也可以加上 `pub` 修饰语来重载该行为。只有从结构体被定义的模块之外访问其字段时，这个可见性才会起作用，其意义是隐藏信息（即封装，encapsulation）。
 
 ```rust,editable
 mod my {

src/mod/super.md

@@ -1,7 +1,6 @@
 # `super` 和 `self`
 
-可以在路径中使用 `super` （父级）和 `self`（自身）关键字，从而在访问项时消除
-歧义，以及防止不必要的路径硬编码。
+可以在路径中使用 `super` （父级）和 `self`（自身）关键字，从而在访问项时消除歧义，以及防止不必要的路径硬编码。
 
 ```rust,editalbe
 fn function() {

src/mod/visibility.md

@@ -1,8 +1,6 @@
 # 可见性
 
-默认情况下，模块中的项拥有私有的可见性（private visibility），不过可以加上
- `pub` 修饰语来重载这一行为。模块中只有公有的（public）项可以从模块外的作用域
-访问。
+默认情况下，模块中的项拥有私有的可见性（private visibility），不过可以加上 `pub` 修饰语来重载这一行为。模块中只有公有的（public）项可以从模块外的作用域访问。
 
 ```rust,editable
 // 一个名为 `my_mod` 的模块

src/scope/borrow/freeze.md

@@ -1,7 +1,6 @@
 # 冻结
 
-当数据被不可变地借用时，它还会**冻结**（freeze）。**已冻结**的数据无法通过原始
-对象来修改，直到对这些数据的所有引用离开作用域为止。
+当数据被不可变地借用时，它还会**冻结**（freeze）。**已冻结**的数据无法通过原始对象来修改，直到对这些数据的所有引用离开作用域为止。
 
 ```rust,editable,ignore,mdbook-runnable
 fn main() {

src/std/box.md

@@ -1,9 +1,6 @@
 # 箱子、栈和堆
 
-在 Rust 中，所有值默认都是栈分配的。通过创建 `Box<T>`，可以把值**装箱**（boxed）来
-使它在堆上分配。箱子（box，即 `Box<T>` 类型的实例）是一个智能指针，指向堆分配
-的 `T` 类型的值。当箱子离开作用域时，它的析构函数会被调用，内部的对象会被
-销毁，堆上分配的内存也会被释放。
+在 Rust 中，所有值默认都是栈分配的。通过创建 `Box<T>`，可以把值**装箱**（boxed）来使它在堆上分配。箱子（box，即 `Box<T>` 类型的实例）是一个智能指针，指向堆分配的 `T` 类型的值。当箱子离开作用域时，它的析构函数会被调用，内部的对象会被销毁，堆上分配的内存也会被释放。
 
 被装箱的值可以使用 `*` 运算符进行解引用；这会移除掉一层装箱。
 

src/std/hash.md

@@ -1,12 +1,8 @@
 # 散列表 HashMap
 
-vector 通过整型下标来存储值，而 `HashMap`（散列表）通过键（key）来存储
-值。`HashMap` 的键可以是布尔型、整型、字符串，或任意实现了 `Eq` 和 `Hash` trait
-的其他类型。在下一节将进一步介绍。
+vector 通过整型下标来存储值，而 `HashMap`（散列表）通过键（key）来存储值。`HashMap` 的键可以是布尔型、整型、字符串，或任意实现了 `Eq` 和 `Hash` trait 的其他类型。在下一节将进一步介绍。
 
-和 vector 类似，`HashMap` 也是可增长的，但 HashMap 在占据了多余空间时还可以缩小
-自己。可以使用 `HashMap::with_capacity(unit)` 创建具有一定初始容量的 HashMap，也
-可以使用 `HashMap::new()` 来获得一个带有默认初始容量的 HashMap（这是推荐方式）。
+和 vector 类似，`HashMap` 也是可增长的，但 HashMap 在占据了多余空间时还可以缩小自己。可以使用 `HashMap::with_capacity(unit)` 创建具有一定初始容量的 HashMap，也可以使用 `HashMap::new()` 来获得一个带有默认初始容量的 HashMap（这是推荐方式）。
 
 ```rust,editable
 use std::collections::HashMap;
@@ -54,7 +50,6 @@ fn main() {
 }
 ```
 
-想要了解更多关于散列（hash）与散列表（hash map）（有时也称作 hash table）的
-工作原理，可以查看 Uncyclopedia 的[散列表][wiki-hash]词条。
+想要了解更多关于散列（hash）与散列表（hash map）（有时也称作 hash table）的工作原理，可以查看 Uncyclopedia 的[散列表][wiki-hash]词条。
 
 [wiki-hash]: https://en.wikipedia.org/wiki/Hash_table

src/std/hash/alt_key_types.md

@@ -7,17 +7,15 @@
 * `String` 和 `&str`（友情提示：如果使用 `String` 作为键来创建 `HashMap`，则可以
   将 `&str` 作为散列表的 `.get()` 方法的参数，以获取值）
 
-注意到 `f32` 和 `f64` **没有**实现 `Hash`，这很大程度上是由于若使用浮点数作为
-散列表的键，[浮点精度误差][floating]会很容易导致错误。
+注意到 `f32` 和 `f64` **没有**实现 `Hash`，这很大程度上是由于若使用浮点数作为散列表的键，[浮点精度误差][floating]会很容易导致错误。
 
 对于所有的集合类（collection class），如果它们包含的类型都分别实现了 `Eq`
 和 `Hash`，那么这些集合类也就实现了 `Eq` 和 `Hash`。例如，若 `T` 实现了
 `Hash`，则 `Vec<T>` 也实现了 `Hash`。
 
 对自定义类型可以轻松地实现 `Eq` 和 `Hash`，只需加上一行代码：`#[derive(PartialEq, Eq, Hash)]`。
 
-编译器将会完成余下的工作。如果你想控制更多的细节，你可以手动
-实现 `Eq` 和/或 `Hash`。本指南不包含实现 `Hash` 的细节内容。
+编译器将会完成余下的工作。如果你想控制更多的细节，你可以手动实现 `Eq` 和/或 `Hash`。本指南不包含实现 `Hash` 的细节内容。
 
 为了试验 `HashMap` 中的 `struct`，让我们试着做一个非常简易的用户登录系统：
 

src/std/hash/hashset.md

@@ -8,11 +8,9 @@
 `HashSet` 的独特之处在于，它保证了不会出现重复的元素。这是任何 set 集合类型（set
 collection）遵循的规定。`HashSet` 只是它的一个实现。（参见：[`BTreeSet`][treeset]）
 
-如果插入的值已经存在于 `HashSet` 中（也就是，新值等于已存在的值，并且拥有相同
-的散列值），那么新值将会替换旧的值。
+如果插入的值已经存在于 `HashSet` 中（也就是，新值等于已存在的值，并且拥有相同的散列值），那么新值将会替换旧的值。
 
-如果你不想要一样东西出现多于一次，或者你要判断一样东西是不是已经存在，这种做法
-就很有用了。
+如果你不想要一样东西出现多于一次，或者你要判断一样东西是不是已经存在，这种做法就很有用了。
 
 不过集合（set）可以做更多的事。
 

src/std/panic.md

@@ -1,8 +1,6 @@
 # `panic!`
 
-`panic!` 宏可用于产生一个 panic （恐慌），并开始回退（unwind）它的栈。在回退栈
-的同时，运行时将会释放该线程所**拥有**的所有资源，这是通过调用线程中所有对象的
-析构函数完成的。
+`panic!` 宏可用于产生一个 panic （恐慌），并开始回退（unwind）它的栈。在回退栈的同时，运行时将会释放该线程所**拥有**的所有资源，这是通过调用线程中所有对象的析构函数完成的。
 
 因为我们正在处理的程序只有一个线程，`panic!` 将会引发程序报告 panic 消息并退出。
 

src/std/result.md

@@ -1,15 +1,11 @@
 # 结果 `Result`
 
-
-我们已经看到 `Option` 枚举类型可以用作可能失败的函数的返回值，其中返回 `None`
-可以表明失败。但是有时要强调**为什么**一个操作会失败。为做到这点，我们提供
-了 `Result` 枚举类型。
+我们已经看到 `Option` 枚举类型可以用作可能失败的函数的返回值，其中返回 `None` 可以表明失败。但是有时要强调**为什么**一个操作会失败。为做到这点，我们提供了 `Result` 枚举类型。
 
 `Result<T, E>` 类型拥有两个取值：
 
 * `Ok(value)` 表示操作成功，并包装操作返回的 `value`（`value` 拥有 `T` 类型）。
-* `Err(why)`，表示操作失败，并包装 `why`，它（但愿）能够解释失败的原因（`why`
-  拥有 `E` 类型）。
+* `Err(why)`，表示操作失败，并包装 `why`，它（但愿）能够解释失败的原因（`why` 拥有 `E` 类型）。
 
 ```rust,editalbe,ignore,mdbook-runnable
 mod checked {

src/std/result/question_mark.md

@@ -1,10 +1,6 @@
 # `?` 运算符
 
-
-把 result 用 match 连接起来会显得很难看；幸运的是，`?` 运算符可以把这种逻辑变得
-干净漂亮。`?` 运算符用在返回值为 `Result` 的表达式后面，它等同于这样一个匹配
-表达式：其中 `Err(err)` 分支展开成提前返回的 `return Err(err)`，而 `Ok(ok)`
-分支展开成 `ok` 表达式。
+把 result 用 match 连接起来会显得很难看；幸运的是，`?` 运算符可以把这种逻辑变得干净漂亮。`?` 运算符用在返回值为 `Result` 的表达式后面，它等同于这样一个匹配表达式：其中 `Err(err)` 分支展开成提前返回的 `return Err(err)`，而 `Ok(ok)` 分支展开成 `ok` 表达式。
 
 ```rust,editable,ignore,mdbook-runnable
 mod checked {

src/std/str.md

@@ -49,18 +49,14 @@ fn main() {
 }
 ```
 
-更多 `str`/`String` 方法可以在 [std::str][str] 和 [std::string][string] 模块中
-找到。
+更多 `str`/`String` 方法可以在 [std::str][str] 和 [std::string][string] 模块中找到。
 
 ## 字面量与转义字符
 
-书写含有特殊字符的字符串字面量有很多种方法。它们都会产生类似的 `&str`，所以最好
-选择最方便的写法。类似地，字节串（byte string）字面量也有多种写法，它们都会产生
+书写含有特殊字符的字符串字面量有很多种方法。它们都会产生类似的 `&str`，所以最好选择最方便的写法。类似地，字节串（byte string）字面量也有多种写法，它们都会产生
 `&[u8; N]` 类型。
 
-通常特殊字符是使用反斜杠字符 `\` 来转义的，这样你就可以在字符串中写入各种各样的
-字符，甚至是不可打印的字符以及你不知道如何输入的字符。如果你需要反斜杠字符，再用
-另一个反斜杠来转义它就可以，像这样：`\\`。
+通常特殊字符是使用反斜杠字符 `\` 来转义的，这样你就可以在字符串中写入各种各样的字符，甚至是不可打印的字符以及你不知道如何输入的字符。如果你需要反斜杠字符，再用另一个反斜杠来转义它就可以，像这样：`\\`。
 
 字面量中出现的字符串或字符定界符必须转义：`"\""`、`'\''`。
 
@@ -86,8 +82,7 @@ fn main() {
 }
 ```
 
-有时会有太多需要转义的字符，或者是直接原样写出会更便利。这时可以使用原始字符
-串（raw string）。
+有时会有太多需要转义的字符，或者是直接原样写出会更便利。这时可以使用原始字符串（raw string）。
 
 ```rust,editable
 fn main() {
@@ -105,8 +100,7 @@ fn main() {
 }
 ```
 
-想要非 UTF-8 字符串（记住，`&str` 和 `String` 都必须是合法的 UTF-8 序列），或者
-需要一个字节数组，其中大部分是文本？请使用字节串（byte string）！
+想要非 UTF-8 字符串（记住，`&str` 和 `String` 都必须是合法的 UTF-8 序列），或者需要一个字节数组，其中大部分是文本？请使用字节串（byte string）！
 
 ```rust,editable
 use std::str;

src/std/vec.md

@@ -1,10 +1,6 @@
 # 动态数组 vector
 
-vector 是大小可变的数组。和 slice（切片）类似，它们的大小在编译时是未知的，但
-它们可以随时扩大或缩小。一个 vector 使用 3 个词来表示：一个指向数据的指针，vector
-的长度，还有它的容量。此容量指明了要为这个 vector 保留多少内存。vector 的长度
-只要小于该容量，就可以随意增长；当需要超过这个阈值时，会给 vector 重新分配一段
-更大的容量。
+vector 是大小可变的数组。和 slice（切片）类似，它们的大小在编译时是未知的，但它们可以随时扩大或缩小。一个 vector 使用 3 个词来表示：一个指向数据的指针，vector 的长度，还有它的容量。此容量指明了要为这个 vector 保留多少内存。vector 的长度只要小于该容量，就可以随意增长；当需要超过这个阈值时，会给 vector 重新分配一段更大的容量。
 
 ```rust,editable,ignore,mdbook-runnable
 fn main() {

src/std_misc/arg.md

@@ -2,8 +2,7 @@
 
 ## 标准库
 
-命令行参数可使用 `std::env::args` 进行接收，这将返回一个迭代器，该迭代器会对
-每个参数举出一个字符串。
+命令行参数可使用 `std::env::args` 进行接收，这将返回一个迭代器，该迭代器会对每个参数举出一个字符串。
 
 ```rust,editable
 use std::env;
@@ -29,7 +28,6 @@ I got 3 arguments: ["1", "2", "3"].
 
 ## crate
 
-另外，也有很多 crate 提供了编写命令行应用的额外功能。[Rust Cookbook] 展示了使用
-最流行的命令行参数 crate，即 `clap` 的最佳实践。
+另外，也有很多 crate 提供了编写命令行应用的额外功能。[Rust Cookbook] 展示了使用最流行的命令行参数 crate，即 `clap` 的最佳实践。
 
 [Rust Cookbook]: https://rust-lang-nursery.github.io/rust-cookbook/app.html#ex-clap-basic

src/std_misc/channels.md

@@ -1,7 +1,6 @@
 # 通道
 
-Rust 为线程之间的通信提供了异步的通道（`channel`）。通道允许两个端点之间信息的
-单向流动：`Sender`（发送端） 和 `Receiver`（接收端）。
+Rust 为线程之间的通信提供了异步的通道（`channel`）。通道允许两个端点之间信息的单向流动：`Sender`（发送端） 和 `Receiver`（接收端）。
 
 ```rust,editable
 use std::sync::mpsc::{Sender, Receiver};

src/std_misc/ffi.md

@@ -1,8 +1,6 @@
 # 外部语言函数接口
 
-Rust 提供了到 C 语言库的外部语言函数接口（Foreign Function Interface，FFI）。外
-部语言函数必须在一个 `extern` 代码块中声明，且该代码块要带有一个包含库名称
-的 `#[link]` 属性。
+Rust 提供了到 C 语言库的外部语言函数接口（Foreign Function Interface，FFI）。外部语言函数必须在一个 `extern` 代码块中声明，且该代码块要带有一个包含库名称的 `#[link]` 属性。
 
 ```rust,ignore
 use std::fmt;