Remove necessary character (#160)

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

Author: Kalmaegi

src/attribute.md

@@ -12,8 +12,7 @@
 * 标记函数作为单元测试
 * 标记函数作为基准测试的某个部分
 
-当属性作用于整个 crate 时，它们的语法为 `#![crate_attribute]`，当它们用于模块
-或项时，语法为 `#[item_attribute]`（注意少了感叹号 `!`）。
+当属性作用于整个 crate 时，它们的语法为 `#![crate_attribute]`，当它们用于模块或项时，语法为 `#[item_attribute]`（注意少了感叹号 `!`）。
 
 属性可以接受参数，有不同的语法形式：
 

src/attribute/crate.md

@@ -1,7 +1,6 @@
 # `crate`
 
-`crate_type` 属性可以告知编译器 crate 是一个二进制的可执行文件还是一个
-库（甚至是哪种类型的库），`crate_name` 属性可以设定 crate 的名称。
+`crate_type` 属性可以告知编译器 crate 是一个二进制的可执行文件还是一个库（甚至是哪种类型的库），`crate_name` 属性可以设定 crate 的名称。
 
 不过，一定要注意在使用 cargo 时，这两种类型时都**没有**作用。由于大多数 Rust
 工程都使用 cargo，这意味着 `crate_type` 和 `crate_name` 的作用事实上很有限。

src/attribute/unused.md

@@ -1,7 +1,6 @@
 # 死代码 `dead_code`
 
-编译器提供了 `dead_code`（死代码，无效代码）[*lint*][lint]，这会对未使用的函数
-产生警告。可以用一个**属性**来禁用这个 lint。
+编译器提供了 `dead_code`（死代码，无效代码）[*lint*][lint]，这会对未使用的函数产生警告。可以用一个**属性**来禁用这个 lint。
 
 ```rust,editable
 fn used_function() {}
@@ -18,7 +17,6 @@ fn main() {
 }
 ```
 
-注意在实际程序中，需要将死代码清除掉。由于本书的例子是交互性的，因而其中需要
-允许一些死代码的出现。
+注意在实际程序中，需要将死代码清除掉。由于本书的例子是交互性的，因而其中需要允许一些死代码的出现。
 
 [lint]: https://en.wikipedia.org/wiki/Lint_%28software%29

src/conversion.md

@@ -1,8 +1,6 @@
 # 类型转换
 
-Rust 使用 [trait][traits] 解决类型之间的转换问题。最一般的转换会用到 [`From`] 
- 和 [`Into`] 两个 trait。不过，即便常见的情况也可能会用到特别的 trait，尤其是
-从 `String` 转换到别的类型，以及把别的类型转换到 `String` 时。
+Rust 使用 [trait][traits] 解决类型之间的转换问题。最一般的转换会用到 [`From`] 和 [`Into`] 两个 trait。不过，即便常见的情况也可能会用到特别的 trait，尤其是从 `String` 转换到别的类型，以及把别的类型转换到 `String` 时。
 
 [traits]: trait.html
 [`From`]: https://rustwiki.org/zh-CN/std/convert/trait.From.html

src/conversion/string.md

@@ -47,9 +47,7 @@ fn main() {
 
 ## 解析字符串
 
-我们经常需要把字符串转成数字。完成这项工作的标准手段是用 [`parse`] 函数。我们得
-提供要转换到的类型，这可以通过不使用类型推断，或者用 “涡轮鱼” 语法（turbo
- fish，`<>`）实现。
+我们经常需要把字符串转成数字。完成这项工作的标准手段是用 [`parse`] 函数。我们得提供要转换到的类型，这可以通过不使用类型推断，或者用 “涡轮鱼” 语法（turbo fish，`<>`）实现。
 
 只要对目标类型实现了 [`FromStr`] trait，就可以用 `parse` 把字符串转换成目标类型。
 标准库中已经给无数种类型实现了 `FromStr`。如果要转换到用户定义类型，只要手动实现

src/conversion/try_from_try_into.md

@@ -1,7 +1,6 @@
 # `TryFrom` and `TryInto`
 
-类似于 [`From` 和 `Into`][from-into]，[`TryFrom`] 和 [`TryInto`] 是
-类型转换的通用 trait。不同于 `From`/`Into` 的是，`TryFrom` 和 `TryInto` trait 用于易出错的转换，也正因如此，其返回值是 [`Result`] 型。
+类似于 [`From` 和 `Into`][from-into]，[`TryFrom`] 和 [`TryInto`] 是类型转换的通用 trait。不同于 `From`/`Into` 的是，`TryFrom` 和 `TryInto` trait 用于易出错的转换，也正因如此，其返回值是 [`Result`] 型。
 
 [from-into]: from_into.html
 [`TryFrom`]: https://rustwiki.org/zh-CN/std/convert/trait.TryFrom.html

src/crates.md

@@ -2,9 +2,7 @@
 
 crate（中文有 “包，包装箱” 之意）是 Rust 的编译单元。当调用 `rustc some_file.rs`
  时，`some_file.rs` 被当作 **crate 文件**。如果 `some_file.rs` 里面含有 `mod`
- 声明，那么模块文件的内容将在编译之前被插入 crate 文件的相应声明处。换句话说，模
-块**不会**单独被编译，只有 crate 才会被编译。
+ 声明，那么模块文件的内容将在编译之前被插入 crate 文件的相应声明处。换句话说，模块**不会**单独被编译，只有 crate 才会被编译。
 
-crate 可以编译成二进制可执行文件（binary）或库文件（library）。默认情况
-下，`rustc` 将从 crate 产生二进制可执行文件。这种行为可以通过 `rustc` 的选项 `--crate-type`
+crate 可以编译成二进制可执行文件（binary）或库文件（library）。默认情况下，`rustc` 将从 crate 产生二进制可执行文件。这种行为可以通过 `rustc` 的选项 `--crate-type`
  重载。

src/crates/lib.md

@@ -24,7 +24,6 @@ $ ls lib*
 library.rlib
 ```
 
-默认情况下，库会使用 crate 文件的名字，前面加上 “lib” 前缀，但这个默认名称可以
-使用 [`crate_name` 属性][crate-name] 覆盖。
+默认情况下，库会使用 crate 文件的名字，前面加上 “lib” 前缀，但这个默认名称可以使用 [`crate_name` 属性][crate-name] 覆盖。
 
 [crate-name]: ../attribute/crate.md

src/custom_types/constants.md

@@ -6,10 +6,7 @@ Rust 有两种常量，可以在任意作用域声明，包括全局作用域。
 * `static`：具有 [`'static`][static] 生命周期的，可以是可变的变量（译注：须使用
   `static mut` 关键字）。
 
-有个特例就是 `"string"` 字面量。它可以不经改动就被赋给一个 `static` 变量，因为它
-的类型标记：`&'static str` 就包含了所要求的生命周期 `'static`。其他的引用类型都
-必须特地声明，使之拥有`'static` 生命周期。这两种引用类型的差异似乎也无关紧要，因
-为无论如何，`static` 变量都得显式地声明。
+有个特例就是 `"string"` 字面量。它可以不经改动就被赋给一个 `static` 变量，因为它的类型标记：`&'static str` 就包含了所要求的生命周期 `'static`。其他的引用类型都必须特地声明，使之拥有 `'static` 生命周期。这两种引用类型的差异似乎也无关紧要，因为无论如何，`static` 变量都得显式地声明。
 
 ```rust,editable,ignore,mdbook-runnable
 // 全局变量是在所有其他作用域之外声明的。

src/error.md

@@ -1,11 +1,8 @@
 # 错误处理
 
-错误处理（error handling）是处理可能发生的失败情况的过程。例如读取一个文件时
-失败了，如果继续使用这个**无效的**输入，那显然是有问题的。注意到并且显式地
-处理这种错误可以避免程序的其他部分产生潜在的问题。
+错误处理（error handling）是处理可能发生的失败情况的过程。例如读取一个文件时失败了，如果继续使用这个**无效的**输入，那显然是有问题的。注意到并且显式地处理这种错误可以避免程序的其他部分产生潜在的问题。
 
-在 Rust 中有多种处理错误的方式，在接下来的小节中会一一介绍。它们多少有些
-区别，使用场景也不尽相同。总的来说：
+在 Rust 中有多种处理错误的方式，在接下来的小节中会一一介绍。它们多少有些区别，使用场景也不尽相同。总的来说：
 
 * 显式的 `panic` 主要用于测试，以及处理不可恢复的错误。在原型开发中这很有用，比如
   用来测试还没有实现的函数，不过这时使用 `unimplemented` 更能表达意图。另外在

src/error/iter_result.md

@@ -32,8 +32,7 @@ fn main() {
 
 ## 使用 `collect()` 使整个操作失败
 
-`Result` 实现了 `FromIter`，因此结果的向量（`Vec<Result<T, E>>`）可以被转换成
-结果包裹着向量（`Result<Vec<T>, E>`）。一旦找到一个 `Result::Err` ，遍历就被终止。
+`Result` 实现了 `FromIter`，因此结果的向量（`Vec<Result<T, E>>`）可以被转换成结果包裹着向量（`Result<Vec<T>, E>`）。一旦找到一个 `Result::Err` ，遍历就被终止。
 
 ```rust,editable
 fn main() {
@@ -62,8 +61,7 @@ fn main() {
 }
 ```
 
-当你看着这些结果时，你会发现所有东西还在 `Result` 中保存着。要取出它们，需要一些
-模板化的代码。
+当你看着这些结果时，你会发现所有东西还在 `Result` 中保存着。要取出它们，需要一些模板化的代码。
 
 ```rust,editable
 fn main() {

src/error/multiple_error_types.md

@@ -4,8 +4,7 @@
 和其他 `Option` 交互。
 
 有时 `Option` 需要和 `Result` 进行交互，或是 `Result<T, Error1>` 需要和
-`Result<T, Error2>` 进行交互。在这类情况下，我们想要以一种方式来管理不同的错误
-类型，使得它们可组合且易于交互。
+`Result<T, Error2>` 进行交互。在这类情况下，我们想要以一种方式来管理不同的错误类型，使得它们可组合且易于交互。
 
 在下面代码中，`unwrap` 的两个实例生成了不同的错误类型。`Vec::first` 返回一个
 `Option`，而 `parse::<i32>` 返回一个 `Result<i32, ParseIntError>`：

src/error/multiple_error_types/boxing_errors.md

@@ -1,11 +1,8 @@
 # 把错误 “装箱”
 
-如果又想写简单的代码，又想保存原始错误信息，一个方法是把它们[装箱][box]（`Box`）。这
-样做的坏处就是，被包装的错误类型只能在运行时了解，而不能被[静态地
-判别][dynamic_dispatch]。
+如果又想写简单的代码，又想保存原始错误信息，一个方法是把它们[装箱][box]（`Box`）。这样做的坏处就是，被包装的错误类型只能在运行时了解，而不能被[静态地判别][dynamic_dispatch]。
 
-对任何实现了 `Error` trait 的类型，标准库的 `Box` 通过 [`From`][from] 为它们提供了
-到 `Box<Error>` 的转换。
+对任何实现了 `Error` trait 的类型，标准库的 `Box` 通过 [`From`][from] 为它们提供了到 `Box<Error>` 的转换。
 
 ```rust,editable
 use std::error;

src/error/multiple_error_types/define_error_type.md

@@ -1,7 +1,6 @@
 # 定义一个错误类型
 
-有时候把所有不同的错误都视为一种错误类型会简化代码。我们将用一个自定义错误类型来
-演示这一点。
+有时候把所有不同的错误都视为一种错误类型会简化代码。我们将用一个自定义错误类型来演示这一点。
 
 Rust 允许我们定义自己的错误类型。一般来说，一个 “好的” 错误类型应当：
 

src/error/multiple_error_types/wrap_error.md

@@ -72,8 +72,7 @@ fn main() {
 }
 ```
 
-这种做法会在错误处理中增加一些模板化的代码，而且也不是所有的应用都需要这样做。一些
-库可以帮你处理模板化代码的问题。
+这种做法会在错误处理中增加一些模板化的代码，而且也不是所有的应用都需要这样做。一些库可以帮你处理模板化代码的问题。
 
 ### See also:
 

src/error/option_unwrap.md

@@ -1,25 +1,17 @@
 # `Option` 和 `unwrap`
 
-上个例子展示了如何主动地引入程序失败（program failure）。当公主收到蛇这件不合适
-的礼物时，我们就让程序 `panic`。但是，如果公主期待收到礼物，却没收到呢？这同样
-是一件糟糕的事情，所以我们要想办法来解决这个问题！
+上个例子展示了如何主动地引入程序失败（program failure）。当公主收到蛇这件不合适的礼物时，我们就让程序 `panic`。但是，如果公主期待收到礼物，却没收到呢？这同样是一件糟糕的事情，所以我们要想办法来解决这个问题！
 
-我们**可以**检查空字符串（`""`），就像处理蛇那样。但既然我们在用 Rust，不如
-让编译器辨别没有礼物的情况。
+我们**可以**检查空字符串（`""`），就像处理蛇那样。但既然我们在用 Rust，不如让编译器辨别没有礼物的情况。
 
-在标准库（`std`）中有个叫做 `Option<T>`（option 中文意思是 “选项”）的枚举
-类型，用于有 “不存在” 的可能性的情况。它表现为以下两个 “option”（选项）中
-的一个：
+在标准库（`std`）中有个叫做 `Option<T>`（option 中文意思是 “选项”）的枚举类型，用于有 “不存在” 的可能性的情况。它表现为以下两个 “option”（选项）中的一个：
 
 * `Some(T)`：找到一个属于 `T` 类型的元素
 * `None`：找不到相应元素
 
-这些选项可以通过 `match` 显式地处理，或使用 `unwrap` 隐式地处理。隐式处理要么
-返回 `Some` 内部的元素，要么就 `panic`。
+这些选项可以通过 `match` 显式地处理，或使用 `unwrap` 隐式地处理。隐式处理要么返回 `Some` 内部的元素，要么就 `panic`。
 
-请注意，手动使用 [expect][expect] 方法自定义 `panic` 信息是可能的，但相比显式
-处理，`unwrap` 的输出仍显得不太有意义。在下面例子中，显式处理将举出更受控制的
-结果，同时如果需要的话，仍然可以使程序 `panic`。
+请注意，手动使用 [expect][expect] 方法自定义 `panic` 信息是可能的，但相比显式处理，`unwrap` 的输出仍显得不太有意义。在下面例子中，显式处理将举出更受控制的结果，同时如果需要的话，仍然可以使程序 `panic`。
 
 ```rust,editable,ignore,mdbook-runnable
 // 平民（commoner）们见多识广，收到什么礼物都能应对。

src/error/option_unwrap/and_then.md

@@ -1,15 +1,13 @@
 # 组合算子：`and_then`
 
 `map()` 以链式调用的方式来简化 `match` 语句。然而，如果以返回类型是 `Option<T>`
- 的函数作为 `map()` 的参数，会导致出现嵌套形式 `Option<Option<T>>`。这样多层串联
-调用就会变得混乱。所以有必要引入 `and_then()`，在某些语言中它叫做 flatmap。
+ 的函数作为 `map()` 的参数，会导致出现嵌套形式 `Option<Option<T>>`。这样多层串联调用就会变得混乱。所以有必要引入 `and_then()`，在某些语言中它叫做 flatmap。
 
 `and_then()` 使用被 `Option` 包裹的值来调用其输入函数并返回结果。 如果 `Option`
  是 `None`，那么它返回 `None`。
 
 在下面例子中，`cookable_v2()` 会产生一个 `Option<Food>`。如果在这里使用 `map()`
-而不是 `and_then()` 将会得到 `Option<Option<Food>>`，这对 `eat()` 来说是一个
-无效类型。
+而不是 `and_then()` 将会得到 `Option<Option<Food>>`，这对 `eat()` 来说是一个无效类型。
 
 ```rust,editable
 #![allow(dead_code)]

src/error/option_unwrap/map.md

@@ -1,8 +1,6 @@
 # 组合算子：`map`
 
-`match` 是处理 `Option` 的一个可用的方法，但你会发现大量使用它会很繁琐，特别是当
-操作只对一种输入是有效的时。这时，可以使用[组合算子][combinators]（combinator），以
-模块化的风格来管理控制流。
+`match` 是处理 `Option` 的一个可用的方法，但你会发现大量使用它会很繁琐，特别是当操作只对一种输入是有效的时。这时，可以使用[组合算子][combinators]（combinator），以模块化的风格来管理控制流。
 
 `Option` 有一个内置方法 `map()`，这个组合算子可用于 `Some -> Some` 和
 `None -> None` 这样的简单映射。多个不同的 `map()` 调用可以串起来，这样更加灵活。

src/error/panic.md

@@ -1,7 +1,6 @@
 # `panic`
 
-我们将要看到的最简单的错误处理机制就是 `panic`。它会打印一个错误消息，开始
-回退（unwind）任务，且通常会退出程序。这里我们显式地在错误条件下调用 `panic`：
+我们将要看到的最简单的错误处理机制就是 `panic`。它会打印一个错误消息，开始回退（unwind）任务，且通常会退出程序。这里我们显式地在错误条件下调用 `panic`：
 
 ```rust,editable,ignore,mdbook-runnable
 fn give_princess(gift: &str) {

src/error/result.md

@@ -1,7 +1,6 @@
 # 结果 `Result`
 
-[`Result`][result] 是 [`Option`][option] 类型的更丰富的版本，描述的是可能
-的**错误**而不是可能的**不存在**。
+[`Result`][result] 是 [`Option`][option] 类型的更丰富的版本，描述的是可能的**错误**而不是可能的**不存在**。
 
 也就是说，`Result<T，E>` 可以有两个结果的其中一个：
 
@@ -36,8 +35,7 @@ fn main() {
 }
 ```
 
-在失败的情况下，`parse()` 产生一个错误，留给 `unwrap()` 来解包并产生 `panic`。另
-外，`panic` 会退出我们的程序，并提供一个让人很不爽的错误消息。
+在失败的情况下，`parse()` 产生一个错误，留给 `unwrap()` 来解包并产生 `panic`。另外，`panic` 会退出我们的程序，并提供一个让人很不爽的错误消息。
 
 为了改善错误消息的质量，我们应该更具体地了解返回类型并考虑显式地处理错误。
 

src/error/result/early_returns.md

@@ -3,8 +3,7 @@
 在上一个例子中，我们显式地使用组合算子处理了错误。另一种处理错误的方式是使用
 `match` 语句和**提前返回**（early return）的结合。
 
-这也就是说，如果发生错误，我们可以停止函数的执行然后返回错误。对有些人来说，这样
-的代码更好写，更易读。这次我们使用提前返回改写之前的例子：
+这也就是说，如果发生错误，我们可以停止函数的执行然后返回错误。对有些人来说，这样的代码更好写，更易读。这次我们使用提前返回改写之前的例子：
 
 ```rust,editable
 use std::num::ParseIntError;
@@ -36,8 +35,7 @@ fn main() {
 }
 ```
 
-到此为止，我们已经学会了如何使用组合算子和提前返回显式地处理错误。我们一般是
-想要避免 panic 的，但显式地处理所有错误确实显得过于繁琐。
+到此为止，我们已经学会了如何使用组合算子和提前返回显式地处理错误。我们一般是想要避免 panic 的，但显式地处理所有错误确实显得过于繁琐。
 
 在下一部分，我们将看到，当只是需要 `unwrap` 并且不产生 `panic` 时，可以使用
 `?` 来达到同样的效果。

src/error/result/enter_question_mark.md

@@ -1,15 +1,13 @@
 # 引入 `?`
 
-有时我们只是想 `unwrap` 且避免产生 `panic`。到现在为止，对 `unwrap` 的错误处理都在强迫
-我们一层层地嵌套，然而我们只是想把里面的变量拿出来。`?` 正是为这种情况准备的。
+有时我们只是想 `unwrap` 且避免产生 `panic`。到现在为止，对 `unwrap` 的错误处理都在强迫我们一层层地嵌套，然而我们只是想把里面的变量拿出来。`?` 正是为这种情况准备的。
 
 当找到一个 `Err` 时，可以采取两种行动：
 
 1. `panic!`，不过我们已经决定要尽可能避免 panic 了。
 2. 返回它，因为 `Err` 就意味着它已经不能被处理了。
 
-`?` **几乎**[^†] 就等于一个会返回 `Err` 而不是 `panic` 的 `unwrap`。我们来看看
-怎样简化之前使用组合算子的例子：
+`?` **几乎**[^†] 就等于一个会返回 `Err` 而不是 `panic` 的 `unwrap`。我们来看看怎样简化之前使用组合算子的例子：
 
 ```rust,editable
 use std::num::ParseIntError;
@@ -36,9 +34,7 @@ fn main() {
 
 ## `try!` 宏
 
-在 `?` 出现以前，相同的功能是使用 `try!` 宏完成的。现在我们推荐使用 `?` 运算符，但是
-在老代码中仍然会看到 `try!`。如果使用 `try!` 的话，上一个例子中的 `multiply` 函数
-看起来会像是这样：
+在 `?` 出现以前，相同的功能是使用 `try!` 宏完成的。现在我们推荐使用 `?` 运算符，但是在老代码中仍然会看到 `try!`。如果使用 `try!` 的话，上一个例子中的 `multiply` 函数看起来会像是这样：
 
 ```rust,editable,edition2015
 use std::num::ParseIntError;