Merge pull request #367 from AllanDowney/patch-5

Update: unified format

book/contents/basic/trait/advance-trait.md

@@ -1,6 +1,6 @@
 # 深入了解特征
 
-特征之于Rust更甚于接口之于其他语言，因此特征在Rust中很重要也相对较为复杂，我们决定把特征分为两篇进行介绍，[第一篇](./trait.md)在之前已经讲过，现在就是第二篇：关于特征的进阶篇，会讲述一些不常用到但是你该了解的特性。
+特征之于 Rust 更甚于接口之于其他语言，因此特征在 Rust 中很重要也相对较为复杂，我们决定把特征分为两篇进行介绍，[第一篇](./trait.md)在之前已经讲过，现在就是第二篇：关于特征的进阶篇，会讲述一些不常用到但是你该了解的特性。
 
 ## 关联类型
 在方法一章中，我们讲到了[关联函数](../method.md#关联函数)，但是实际上关联类型和关联函数并没有任何交集，虽然它们的名字有一半的交集。
@@ -46,7 +46,7 @@ pub trait CacheableItem: Clone + Default + fmt::Debug + Decodable + Encodable {
 }
 ```
 
-例如上面的代码， `Address` 的写法自然远比 `AsRef<[u8]> + Clone + fmt::Debug + Eq + Hash` 要简单的多，而且含义清晰。
+例如上面的代码，`Address` 的写法自然远比 `AsRef<[u8]> + Clone + fmt::Debug + Eq + Hash` 要简单的多，而且含义清晰。
 
 再例如，如果使用泛型，你将得到以下的代码：
 ```rust
@@ -108,7 +108,7 @@ fn main() {
                Point { x: 3, y: 3 });
 }
 ```
-上面的代码主要干了一件事，就是为 `Point` 结构体提供 `+` 的能力，这就是**运算符重载**，不过Rust并不支持创建自定义运算符，你也无法为所有运算符进行重载，目前来说，只有定义在 `std::ops` 中的运算符才能进行重载。
+上面的代码主要干了一件事，就是为 `Point` 结构体提供 `+` 的能力，这就是**运算符重载**，不过 Rust 并不支持创建自定义运算符，你也无法为所有运算符进行重载，目前来说，只有定义在 `std::ops` 中的运算符才能进行重载。
 
 跟 `+` 对应的特征是 `std::ops::Add`，我们在之前也看过它的定义 `trait Add<RHS=Self>`，但是上面的例子中并没有为 `Point` 实现 `Add<RHS>` 特征，而是实现了 `Add` 特征（没有默认泛型类型参数），这意味着我们使用了 `RHS` 的默认类型，也就是 `Self`。换句话说，我们这里定义的是两个相同的 `Point` 类型相加，因此无需指定 `RHS`。
 
@@ -264,16 +264,16 @@ fn main() {
     println!("A baby dog is called a {}", <Dog as Animal>::baby_name());
 }
 ```
-在尖括号中，通过 `as` 关键字，我们向Rust编译器提供了类型注解，也就是 `Animal` 就是 `Dog`，而不是其他动物，因此最终会调用 `impl Animal for Dog` 中的方法，获取到其它动物对狗宝宝的称呼：**puppy**。
+在尖括号中，通过 `as` 关键字，我们向 Rust 编译器提供了类型注解，也就是 `Animal` 就是 `Dog`，而不是其他动物，因此最终会调用 `impl Animal for Dog` 中的方法，获取到其它动物对狗宝宝的称呼：**puppy**。
 
 言归正题，完全限定语法定义为：
 ```rust
 <Type as Trait>::function(receiver_if_method, next_arg, ...);
 ```
 
-上面定义中，第一个参数是方法接收器`receiver`(三种`self`)，只有方法才拥有，例如关联函数就没有`receiver`。
+上面定义中，第一个参数是方法接收器 `receiver` （三种 `self`），只有方法才拥有，例如关联函数就没有 `receiver`。
 
-完全限定语法可以用于任何函数或方法调用，那么我们为何很少用到这个语法？原因是Rust编译器能根据上下文自动推导出调用的路径，因此大多数时候，我们都无需使用完全限定语法。只有当存在多个同名函数或方法，且Rust无法区分出你想调用的目标函数时，该用法才能真正有用武之地。
+完全限定语法可以用于任何函数或方法调用，那么我们为何很少用到这个语法？原因是 Rust 编译器能根据上下文自动推导出调用的路径，因此大多数时候，我们都无需使用完全限定语法。只有当存在多个同名函数或方法，且 Rust 无法区分出你想调用的目标函数时，该用法才能真正有用武之地。
 
 
 
@@ -299,7 +299,7 @@ trait OutlinePrint: Display {
 
 等等，这里有一个眼熟的语法: `OutlinePrint: Display`，感觉很像之前讲过的**特征约束**，只不过用在了特征定义中而不是函数的参数中，是的，在某种意义上来说，这和特征约束非常类似，都用来说明一个特征需要实现另一个特征，这里就是：如果你想要实现 `OutlinePrint` 特征，首先你需要实现 `Display` 特征。
 
-想象一下，假如没有这个特征约束，那么 `self.to_string` 还能够调用吗( `to_string` 方法会为实现 `Display` 特征的类型自动实现)？编译器肯定是不愿意的，会报错说当前作用域中找不到用于 `&Self` 类型的方法 `to_string` ：
+想象一下，假如没有这个特征约束，那么 `self.to_string` 还能够调用吗（ `to_string` 方法会为实现 `Display` 特征的类型自动实现）？编译器肯定是不愿意的，会报错说当前作用域中找不到用于 `&Self` 类型的方法 `to_string` ：
 ```rust
 struct Point {
     x: i32,
@@ -378,13 +378,13 @@ fn main() {
 }
 ```
 
-其中， `struct Wrapper(Vec<String>)` 就是一个元组结构体，它定义了一个新类型 `Wrapper`，代码很简单，相信大家也很容易看懂。
+其中，`struct Wrapper(Vec<String>)` 就是一个元组结构体，它定义了一个新类型 `Wrapper`，代码很简单，相信大家也很容易看懂。
 
-既然`new type`有这么多好处，它有没有不好的地方呢？答案是肯定的。注意到我们怎么访问里面的数组吗？`self.0.join(", ")`，是的，很啰嗦，因为需要先从 `Wrapper` 中取出数组: `self.0`，然后才能执行 `join` 方法。
+既然 `new type` 有这么多好处，它有没有不好的地方呢？答案是肯定的。注意到我们怎么访问里面的数组吗？`self.0.join(", ")`，是的，很啰嗦，因为需要先从 `Wrapper` 中取出数组: `self.0`，然后才能执行 `join` 方法。
 
 类似的，任何数组上的方法，你都无法直接调用，需要先用 `self.0` 取出数组，然后再进行调用。
 
-当然，解决办法还是有的，要不怎么说Rust是极其强大灵活的编程语言！Rust提供了一个特征叫[ `Deref` ](../../traits/deref.md)，实现该特征后，可以自动做一层类似类型转换的操作，可以将 `Wrapper` 变成 `Vec<String>` 来使用。这样就会像直接使用数组那样去使用 `Wrapper`，而无需为每一个操作都添加上 `self.0`。
+当然，解决办法还是有的，要不怎么说 Rust 是极其强大灵活的编程语言！Rust 提供了一个特征叫 [`Deref`](../../traits/deref.md)，实现该特征后，可以自动做一层类似类型转换的操作，可以将 `Wrapper` 变成 `Vec<String>` 来使用。这样就会像直接使用数组那样去使用 `Wrapper`，而无需为每一个操作都添加上 `self.0`。
 
 同时，如果不想 `Wrapper` 暴漏底层数组的所有方法，我们还可以为 `Wrapper` 去重载这些方法，实现隐藏的目的。
 

book/contents/basic/trait/generic.md

@@ -1,6 +1,6 @@
 # 泛型Generics
 
-Go语言在2022年，就要正式引入泛型，被视为在1.0版本后，语言特性发展迈出的一大步，为什么泛型这么重要？到底什么是泛型？Rust的泛型有几种？
+Go 语言在 2022 年，就要正式引入泛型，被视为在 1.0 版本后，语言特性发展迈出的一大步，为什么泛型这么重要？到底什么是泛型？Rust 的泛型有几种？
 本章将一一为你讲解。
 
 我们在编程中，经常有这样的需求：用同一功能的函数处理不同类型的数据，例如两个数的加法，无论是整数还是浮点数，甚至是自定义类型，都能进行支持。在不支持泛型的编程语言中，通常需要为每一种类型编写一个函数：
@@ -22,9 +22,9 @@ fn main() {
 }
 ```
 
-上述代码可以正常运行，但是很啰嗦，如果你要支持更多的类型，那么会更繁琐。程序员或多或少都有强迫症，一个好程序员的公认特征就是 - 懒，这么勤快的写一大堆代码，显然不是咱们的优良传统，是不？
+上述代码可以正常运行，但是很啰嗦，如果你要支持更多的类型，那么会更繁琐。程序员或多或少都有强迫症，一个好程序员的公认特征就是 —— 懒，这么勤快的写一大堆代码，显然不是咱们的优良传统，是不？
 
-在开始讲解Rust的泛型之前，先来看看什么是多态。
+在开始讲解 Rust 的泛型之前，先来看看什么是多态。
 
 在编程的时候，我们经常利用多态。通俗的讲，多态就是好比坦克的炮管，既可以发射普通弹药，也可以发射制导炮弹（导弹），也可以发射贫铀穿甲弹，甚至发射子母弹，没有必要为每一种炮弹都在坦克上分别安装一个专用炮管，即使生产商愿意，炮手也不愿意，累死人啊。所以在编程开发中，我们也需要这样“通用的炮管”，这个“通用的炮管”就是多态。
 
@@ -40,10 +40,10 @@ fn main() {
     println!("add f64: {}", add(1.23, 1.23));
 }
 ```
-将之前的代码改成上面这样，就是Rust泛型的初印象，这段代码虽然很简洁，但是并不能编译通过，我们会在后面进行详细讲解，现在只要对泛型有个大概的印象即可。
+将之前的代码改成上面这样，就是 Rust 泛型的初印象，这段代码虽然很简洁，但是并不能编译通过，我们会在后面进行详细讲解，现在只要对泛型有个大概的印象即可。
 
 ## 泛型详解
-上面代码的 `T` 就是**泛型参数**，实际上在Rust中，泛型参数的名称你可以任意起，但是出于惯例，我们都用 `T` ( `T` 是 `type` 的首字母)来作为首选，这个名称越短越好，除非需要表达含义，否则一个字母是最完美的。
+上面代码的 `T` 就是**泛型参数**，实际上在 Rust 中，泛型参数的名称你可以任意起，但是出于惯例，我们都用 `T` ( `T` 是 `type` 的首字母)来作为首选，这个名称越短越好，除非需要表达含义，否则一个字母是最完美的。
 
 使用泛型参数，有一个先决条件，必需在使用前对其进行声明：
 ```rust
@@ -222,7 +222,7 @@ fn main() {
 }
 ```
 
-使用泛型参数前，依然需要提前声明：`impl<T>`，只有提前声明了，我们才能在`Point<T>`中使用它，这样Rust就知道 `Point` 的尖括号中的类型是泛型而不是具体类型。需要注意的是，这里的 `Point<T>` 不再是泛型声明，而是一个完整的结构体类型，因为我们定义的结构体就是 `Point<T>` 而不再是 `Point`。
+使用泛型参数前，依然需要提前声明：`impl<T>`，只有提前声明了，我们才能在`Point<T>`中使用它，这样 Rust 就知道 `Point` 的尖括号中的类型是泛型而不是具体类型。需要注意的是，这里的 `Point<T>` 不再是泛型声明，而是一个完整的结构体类型，因为我们定义的结构体就是 `Point<T>` 而不再是 `Point`。
 
 除了结构体中的泛型参数，我们还能在该结构体的方法中定义额外的泛型参数，就跟泛型函数一样：
 
@@ -268,7 +268,7 @@ impl Point<f32> {
 
 
 
-## const泛型（Rust 1.51版本引入的重要特性）
+## const 泛型（Rust 1.51 版本引入的重要特性）
 在之前的泛型中，可以抽象为一句话：针对类型实现的泛型，所有的泛型都是为了抽象不同的类型，那有没有针对值的泛型？可能很多同学感觉很难理解，值怎么使用泛型？不急，我们先从数组讲起。
 
 在[数组](../compound-type/array.md)那节，有提到过很重要的一点：`[i32; 2]` 和 `[i32; 3]` 是不同的数组类型，比如下面的代码：
@@ -327,11 +327,11 @@ fn main() {
 }
 ```
 
-也不难，唯一要注意的是需要对T加一个限制 `std::fmt::Debug`，该限制表明 `T` 可以用在 `println!("{:?}", arr)`中，因为 `{:?}` 形式的格式化输出需要 `arr` 实现该特征。
+也不难，唯一要注意的是需要对T加一个限制 `std::fmt::Debug`，该限制表明 `T` 可以用在 `println!("{:?}", arr)` 中，因为 `{:?}` 形式的格式化输出需要 `arr` 实现该特征。
 
-通过引用，我们可以很轻松的解决处理任何类型数组的问题，但是如果在某些场景下引用不适宜用或者干脆不能用呢？你们知道为什么以前Rust的一些数组库，在使用的时候都限定长度不超过32吗？因为它们会为每个长度都单独实现一个函数，简直。。。毫无人性。难道没有什么办法可以解决这个问题吗？
+通过引用，我们可以很轻松的解决处理任何类型数组的问题，但是如果在某些场景下引用不适宜用或者干脆不能用呢？你们知道为什么以前 Rust 的一些数组库，在使用的时候都限定长度不超过32吗？因为它们会为每个长度都单独实现一个函数，简直。。。毫无人性。难道没有什么办法可以解决这个问题吗？
 
-好在，现在咱们有了const泛型，也就是针对值的泛型，正好可以用于处理数组长度的问题：
+好在，现在咱们有了 const 泛型，也就是针对值的泛型，正好可以用于处理数组长度的问题：
 ```rust
 fn display_array<T: std::fmt::Debug, const N: usize>(arr: [T; N]) {
     println!("{:?}", arr);
@@ -347,12 +347,12 @@ fn main() {
 
 如上所示，我们定义了一个类型为 `[T; N]` 的数组，其中 `T` 是一个基于类型的泛型参数，这个和之前讲的泛型没有区别，而重点在于 `N` 这个泛型参数，它是一个基于值的泛型参数！因为它用来替代的是数组的长度。
 
-`N` 就是const泛型，定义的语法是 `const N: usize`，表示const泛型N，它基于的值类型是 `usize`。
+`N` 就是 const 泛型，定义的语法是 `const N: usize`，表示 const 泛型 `N` ，它基于的值类型是 `usize`。
 
-在泛型参数之前，Rust完全不适合复杂矩阵的运算，自从有了const泛型，一切即将改变。
+在泛型参数之前，Rust 完全不适合复杂矩阵的运算，自从有了 const 泛型，一切即将改变。
 
-#### const泛型表达式
-假设我们某段代码需要在内存很小的平台上工作，因此需要限制函数参数占用的内存大小，此时就可以使用const泛型表达式来实现：
+#### const 泛型表达式
+假设我们某段代码需要在内存很小的平台上工作，因此需要限制函数参数占用的内存大小，此时就可以使用 const 泛型表达式来实现：
 ```rust
 // 目前只能在nightly版本下使用
 #![allow(incomplete_features)]
@@ -361,7 +361,7 @@ fn main() {
 fn something<T>(val: T)
 where
     Assert<{ core::mem::size_of::<T>() < 768 }>: IsTrue,
-    //       ^-----------------------------^ 这里是一个const表达式，换成其它的const表达式也可以
+    //       ^-----------------------------^ 这里是一个 const 表达式，换成其它的 const 表达式也可以
 {
     //
 }
@@ -392,9 +392,9 @@ impl IsTrue for Assert<true> {
 
 ## 泛型的性能
 
-在Rust中泛型是零成本的抽象，意味着你在使用泛型时，完全不用担心性能上的问题。
+在 Rust 中泛型是零成本的抽象，意味着你在使用泛型时，完全不用担心性能上的问题。
 
-但是任何选择都是权衡得失的，既然我们获得了性能上的巨大优势，那么又失去了什么呢？Rust是在编译期为泛型对应的多个类型，生成各自的代码，因此损失了编译速度和增大了最终生成文件的大小。
+但是任何选择都是权衡得失的，既然我们获得了性能上的巨大优势，那么又失去了什么呢？Rust 是在编译期为泛型对应的多个类型，生成各自的代码，因此损失了编译速度和增大了最终生成文件的大小。
 
 具体来说：
 

book/contents/basic/trait/intro.md

@@ -1,3 +1,3 @@
 # 泛型和特征
 
-泛型和特征是Rust中最最重要的抽象类型，也是你在学习Rust路上的拦路虎，但是挑战往往与乐趣并存，一旦学会，在后面学习Rust的路上，你将一往无前。
+泛型和特征是 Rust 中最最重要的抽象类型，也是你在学习 Rust 路上的拦路虎，但是挑战往往与乐趣并存，一旦学会，在后面学习 Rust 的路上，你将一往无前。

book/contents/basic/trait/trait-object.md

@@ -17,7 +17,7 @@ fn returns_summarizable(switch: bool) -> impl Summary {
 其中 `Post` 和 `Weibo` 都实现了 `Summary` 特征，因此上面的函数试图通过返回 `impl Summary` 来返回这两个类型，但是编译器却无情地报错了，原因是
  `impl Trait` 的返回值类型并不支持多种不同的类型返回，那如果我们想返回多种类型，该怎么办？
 
-再来考虑一个问题：现在在做一款游戏，需要将多个对象渲染在屏幕上，这些对象属于不同的类型，存储在列表中，渲染的时候，需要循环该列表并顺序渲染每个对象，在Rust中该怎么实现？
+再来考虑一个问题：现在在做一款游戏，需要将多个对象渲染在屏幕上，这些对象属于不同的类型，存储在列表中，渲染的时候，需要循环该列表并顺序渲染每个对象，在 Rust 中该怎么实现？
 
 聪明的同学可能已经能想到一个办法，利用枚举：
 ```rust
@@ -43,19 +43,19 @@ fn draw(o: UiObject) {
 }
 ```
 
-Bingo，这个确实是一个办法，但是问题来了，如果你的对象集合并不能事先明确地知道呢？或者别人想要实现一个UI组件呢？此时枚举中的类型是有些缺少的，是不是还要修改你的代码增加一个枚举成员？
+Bingo，这个确实是一个办法，但是问题来了，如果你的对象集合并不能事先明确地知道呢？或者别人想要实现一个 UI 组件呢？此时枚举中的类型是有些缺少的，是不是还要修改你的代码增加一个枚举成员？
 
-总之，在编写这个UI库时，我们无法知道所有的UI对象类型，只知道的是：
-- UI对象的类型不同
+总之，在编写这个 UI 库时，我们无法知道所有的 UI 对象类型，只知道的是：
+- UI 对象的类型不同
 - 需要一个统一的类型来处理这些对象，无论是作为函数参数还是作为列表中的一员
 - 需要对每一个对象调用 `draw` 方法
 
 在拥有继承的语言中，可以定义一个名为 `Component` 的类，该类上有一个 `draw` 方法。其他的类比如 `Button`、`Image` 和 `SelectBox` 会从 `Component` 派生并因此继承 `draw` 方法。它们各自都可以覆盖 `draw` 方法来定义自己的行为，但是框架会把所有这些类型当作是 `Component` 的实例，并在其上调用 `draw`。不过 Rust 并没有继承，我们得另寻出路。
 
 ## 特征对象定义
-为了解决上面的所有问题，Rust引入了一个概念 - 特征对象。
+为了解决上面的所有问题，Rust 引入了一个概念 —— **特征对象**。
 
-在介绍特征对象之前，先来为之前的UI组件定义一个特征：
+在介绍特征对象之前，先来为之前的 UI 组件定义一个特征：
 ```rust
 pub trait Draw {
     fn draw(&self);
@@ -88,7 +88,7 @@ impl Draw for SelectBox {
 }
 
 ```
-此时，还需要一个动态数组来存储这些UI对象：
+此时，还需要一个动态数组来存储这些 UI 对象：
 ```rust
 pub struct Screen {
     pub components: Vec<?>,
@@ -98,7 +98,7 @@ pub struct Screen {
 
 **特征对象**指向实现了 `Draw` 特征的类型的实例，也就是指向了 `Button` 或者 `SelectBox` 的实例，这种映射关系是存储在一张表中，可以在运行时通过特征对象找到具体调用的类型方法。
 
-可以通过`&`引用或者`Box<T>`智能指针的方式来创建特征对象:
+可以通过 `&` 引用或者 `Box<T>` 智能指针的方式来创建特征对象:
 ```rust
 trait Draw {
     fn draw(&self) -> String; 
@@ -182,7 +182,7 @@ impl<T> Screen<T>
 
 但是这种写法限制了 `Screen` 实例的 `Vec<T>` 中的每个元素必须是 `Button` 类型或者全是 `SelectBox` 类型。如果只需要同质（相同类型）集合，更倾向于这种写法：使用泛型和 特征约束，因为实现更清晰，且性能更好(特征对象，需要在运行时从 `vtable` 动态查找需要调用的方法。
 
-现在来运行渲染下咱们精心设计的UI组件列表：
+现在来运行渲染下咱们精心设计的 UI 组件列表：
 ```rust
 fn main() {
     let screen = Screen {
@@ -207,7 +207,7 @@ fn main() {
     screen.run();
 }
 ```
-上面使用 `Box::new(T)` 的方式来创建了两个 `Box<dyn Draw>` 特征对象，如果以后还需要增加一个UI组件，那么让该组件实现 `Draw` 特征，则可以很轻松的将其渲染在屏幕上，甚至用户可以引入我们的库作为三方库，然后在自己的库中为自己的类型实现 `Draw` 特征，然后进行渲染。
+上面使用 `Box::new(T)` 的方式来创建了两个 `Box<dyn Draw>` 特征对象，如果以后还需要增加一个 UI 组件，那么让该组件实现 `Draw` 特征，则可以很轻松的将其渲染在屏幕上，甚至用户可以引入我们的库作为三方库，然后在自己的库中为自己的类型实现 `Draw` 特征，然后进行渲染。
 
 在动态类型语言中，有一个很重要的概念： **鸭子类型**（*duck typing*），简单来说，就是只关心值长啥样，而不关心它实际是什么。当一个东西走起来像鸭子，叫起来像鸭子，那么它就是一只鸭子，就算它实际上是一个奥特曼，也不重要，我们就当它是鸭子。
 
@@ -231,7 +231,7 @@ fn main() {
 #### &dyn和Box\<dyn\>的区别
 前文提到， `&dyn` 和 `Box<dyn>` 都可以用于特征对象，因此在功能上 `&dyn` 和 `Box<dyn>` 几乎没有区别，唯一的区别就是：`&dyn` 减少了一次指针调用。
 
-因为 `Box<dyn>` 是一个宽指针(`fat pointer`)，它需要一次额外的解引用后，才能获取到指向`vtable`的指针，然后再通过该指针访问 `vtable` 查询到具体的函数指针，最后进行调用。
+因为 `Box<dyn>` 是一个宽指针（`fat pointer`），它需要一次额外的解引用后，才能获取到指向 `vtable` 的指针，然后再通过该指针访问 `vtable` 查询到具体的函数指针，最后进行调用。
 
 所以，如果你在乎性能，又想使用特征对象简化代码，可以优先考虑 `&dyn`。
 
@@ -262,7 +262,7 @@ help: function arguments must have a statically known size, borrowed types alway
 当使用特征对象时，Rust 必须使用动态分发。编译器无法知晓所有可能用于特征对象代码的类型，所以它也不知道应该调用哪个类型的哪个方法实现。为此，Rust 在运行时使用特征对象中的指针来知晓需要调用哪个方法。动态分发也阻止编译器有选择的内联方法代码，这会相应的禁用一些优化。
 
 ## Self与self
-在Rust中，有两个`self`，一个指代当前的实例对象，一个指代特征或者方法类型的别名：
+在 Rust 中，有两个`self`，一个指代当前的实例对象，一个指代特征或者方法类型的别名：
 ```rust
 trait Draw {
     fn draw(&self) ->  Self;

book/contents/basic/trait/trait.md

@@ -1,22 +1,22 @@
 # 特征Trait
-如果我们想定义一个文件系统，那么把该系统跟底层存储解耦是很重要的。文件操作主要包含三个：`open`、`write`、`read`，这些操作可以发生在硬盘，也可以发生在缓存，可以通过网络也可以通过(我实在编不下去了，大家来帮帮我)。总之如果你要为每一种情况都单独实现一套代码，那这种实现将过于繁杂，而且也没那个必要。
+如果我们想定义一个文件系统，那么把该系统跟底层存储解耦是很重要的。文件操作主要包含三个：`open` 、`write`、`read`，这些操作可以发生在硬盘，也可以发生在缓存，可以通过网络也可以通过(我实在编不下去了，大家来帮帮我)。总之如果你要为每一种情况都单独实现一套代码，那这种实现将过于繁杂，而且也没那个必要。
 
-要解决上述问题，需要把这些行为抽象出来，就要使用Rust中的特征 `trait` 概念。可能你是第一次听说这个名词，但是不要怕，如果学过其他语言，那么大概率你听说过接口，没错，特征很类似接口。
+要解决上述问题，需要把这些行为抽象出来，就要使用 Rust 中的特征 `trait` 概念。可能你是第一次听说这个名词，但是不要怕，如果学过其他语言，那么大概率你听说过接口，没错，特征很类似接口。
 
-在之前的代码中，我们也多次见过特征的使用，例如 `#[derive(Debug)]`，它在我们定义的类型（struct）上自动派生 `Debug` 特征，接着可以使用 `println!("{:?}",x)` 打印这个类型；再例如：
+在之前的代码中，我们也多次见过特征的使用，例如 `#[derive(Debug)]`，它在我们定义的类型（`struct`）上自动派生 `Debug` 特征，接着可以使用 `println!("{:?}", x)` 打印这个类型；再例如：
 ```rust
 fn add<T: std::ops::Add<Output = T>>(a:T, b:T) -> T {
     a + b
 }
 ```
-通过 `std::ops::Add` 特征来限制`T`，只有 `T` 实现了 `std::ops::Add` 才能进行合法的加法操作，毕竟不是所有的类型都能进行相加。
+通过 `std::ops::Add` 特征来限制 `T`，只有 `T` 实现了 `std::ops::Add` 才能进行合法的加法操作，毕竟不是所有的类型都能进行相加。
 
 这些都说明一个道理，特征定义了**一个可以被共享的行为，只要实现了特征，你就能使用该行为**。
 
 ## 定义特征
 如果不同的类型具有相同的行为，那么我们就可以定义一个特征，然后为这些类型实现该特征。**定义特征**是把一些方法组合在一起，目的是定义一个实现某些目标所必需的行为的集合。
 
-例如，我们现在有文章`Post`和微博`Weibo`两种内容载体，而我们想对相应的内容进行总结，也就是无论是文章内容，还是微博内容，都可以在某个时间点进行总结，那么总结这个行为就是共享的，因此可以用特征来定义：
+例如，我们现在有文章 `Post` 和微博 `Weibo` 两种内容载体，而我们想对相应的内容进行总结，也就是无论是文章内容，还是微博内容，都可以在某个时间点进行总结，那么总结这个行为就是共享的，因此可以用特征来定义：
 ```rust
 pub trait Summary {
     fn summarize(&self) -> String;
@@ -61,7 +61,7 @@ impl Summary for Weibo {
 }
 ```
 
-实现特征的语法与为结构体、枚举实现方法很像：`impl Summary for Post`，读作“为`Post`类型实现 `Summary` 特征”，然后在 `impl` 的花括号中实现该特征的具体方法。
+实现特征的语法与为结构体、枚举实现方法很像：`impl Summary for Post`，读作“为 `Post` 类型实现 `Summary` 特征”，然后在 `impl` 的花括号中实现该特征的具体方法。
 
 接下来就可以在这个类型上调用特征的方法：
 ```rust
@@ -76,7 +76,7 @@ fn main() {
 
 运行输出：
 ```console
-文章Rust语言简介, 作者是Sunface
+文章 Rust 语言简介, 作者是Sunface
 sunface发表了微博好像微博没Tweet好用
 ```
 
@@ -85,7 +85,7 @@ sunface发表了微博好像微博没Tweet好用
 #### 特征定义与实现的位置(孤儿规则)
 上面我们将 `Summary` 定义成了 `pub` 公开的。这样，如果他人想要使用我们的 `Summary` 特征，则可以引入到他们的包中，然后再进行实现。
 
-关于特征实现与定义的位置，有一条非常重要的原则：**如果你想要为类型 `A` 实现特征 `T`，那么 `A` 或者 `T `至少有一个是在当前作用域中定义的！**。例如我们可以为上面的 `Post` 类型实现标准库中的 `Display` 特征，这是因为 `Post` 类型定义在当前的作用域中。同时，我们也可以在当前包中为 `String` 类型实现 `Summary` 特征，因为 `Summary` 定义在当前作用域中。
+关于特征实现与定义的位置，有一条非常重要的原则：**如果你想要为类型 `A` 实现特征 `T`，那么 `A` 或者 `T` 至少有一个是在当前作用域中定义的！**。例如我们可以为上面的 `Post` 类型实现标准库中的 `Display` 特征，这是因为 `Post` 类型定义在当前的作用域中。同时，我们也可以在当前包中为 `String` 类型实现 `Summary` 特征，因为 `Summary` 定义在当前作用域中。
 
 但是你无法在当前作用域中，为 `String` 类型实现 `Display` 特征，因为它们俩都定义在标准库中，其定义所在的位置都不在当前作用域，跟你半毛钱关系都没有，看看就行了。
 
@@ -112,7 +112,7 @@ impl Summary for Weibo {
 }
 ```
 
-可以看到，`Post`选择了默认实现，而`Weibo`重载了该方法，调用和输出如下：
+可以看到，`Post` 选择了默认实现，而 `Weibo` 重载了该方法，调用和输出如下：
 ```rust
     println!("{}",post.summarize());
     println!("{}",weibo.summarize());
@@ -168,7 +168,7 @@ pub fn notify<T: Summary>(item: &T) {
     println!("Breaking news! {}", item.summarize());
 }
 ```
-真正的完整书写形式如上所述，形如`T:Summary`被称为**特征约束**。
+真正的完整书写形式如上所述，形如 `T: Summary` 被称为**特征约束**。
 
 在简单的场景下 `impl Trait` 的语法就足够使用，但是对于复杂的场景，特征约束可以让我们拥有更大的灵活性和语法表现能力，例如一个函数接受两个 `impl Summary` 的参数：
 ```rust
@@ -192,7 +192,7 @@ pub fn notify(item: &(impl Summary + Display)) {
 ```rust
 pub fn notify<T: Summary + Display>(item: &T) {}
 ```
-通过这两个特征，就可以使用 `item.summarize` 方法，以及通过 `println!("{}",item)` 来格式化输出 `item`。
+通过这两个特征，就可以使用 `item.summarize` 方法，以及通过 `println!("{}", item)` 来格式化输出 `item`。
 
 #### Where约束
 当特征约束变得很多时，函数的签名将变得很复杂：
@@ -237,7 +237,7 @@ impl<T: Display + PartialOrd> Pair<T> {
 }
 ```
 
-`cmd_display` 方法，并不是所有的 `Pair<T>` 结构体对象都可以拥有，只有 `T` 同时实现了 `Display + PartialOrd`的`Part<T>` 才可以拥有此方法。
+`cmd_display` 方法，并不是所有的 `Pair<T>` 结构体对象都可以拥有，只有 `T` 同时实现了 `Display + PartialOrd` 的 `Part<T>` 才可以拥有此方法。
 该函数可读性会更好，因为泛型参数、参数、返回值都在一起，可以快速的阅读，同时每个泛型参数的特征也在新的代码行中通过**特征约束**进行了约束。
 
 **也可以有条件的实现特征**, 例如，标准库为任何实现了 `Display` 特征的类型实现了 `ToString` 特征：
@@ -253,8 +253,8 @@ let s = 3.to_string();
 ```
 
 
-## 函数返回中的`impl Trait`
-可以通过`impl Trait`来说明一个函数返回了一个类型，该类型实现了某个特征：
+## 函数返回中的 `impl Trait`
+可以通过 `impl Trait` 来说明一个函数返回了一个类型，该类型实现了某个特征：
 ```rust
 fn returns_summarizable() -> impl Summary {
     Weibo {
@@ -268,7 +268,7 @@ fn returns_summarizable() -> impl Summary {
 
 因为 `Weibo` 实现了 `Summary`，因此这里可以用它来作为返回值。要注意的是，虽然我们知道这里是一个 `Weibo` 类型，但是对于 `returns_summarizable` 的调用者而言，他只知道返回了一个实现了 `Summary` 特征的对象，但是并不知道返回了一个 `Weibo` 类型。
 
-这种 `impl Trait` 形式的返回值，在一种场景下非常非常有用，那就是返回的真实类型非常复杂，你不知道该怎么声明时(毕竟Rust要求你必须标出所有的类型)，此时就可以用 `impl Trait` 的方式简单返回。例如，闭包和迭代器就是很复杂，只有编译器才知道那玩意的真实类型，如果让你写出来它们的具体类型，我估计想杀人的心都有，好在你可以用 `impl Iterator` 来告诉调用者，返回了一个迭代器，因为所有迭代器都会实现 `Iterator` 特征。
+这种 `impl Trait` 形式的返回值，在一种场景下非常非常有用，那就是返回的真实类型非常复杂，你不知道该怎么声明时(毕竟 Rust 要求你必须标出所有的类型)，此时就可以用 `impl Trait` 的方式简单返回。例如，闭包和迭代器就是很复杂，只有编译器才知道那玩意的真实类型，如果让你写出来它们的具体类型，我估计想杀人的心都有，好在你可以用 `impl Iterator` 来告诉调用者，返回了一个迭代器，因为所有迭代器都会实现 `Iterator` 特征。
 
 但是这种返回值方式有一个很大的限制：只能有一个具体的类型，例如：
 ```rust
@@ -304,10 +304,10 @@ expected struct `Post`, found struct `Weibo`
 
 报错提示我们 `if` 和 `else` 返回了不同的类型。如果想要实现返回不同的类型，需要使用下一章节中的[特征对象](./trait-object.md)。
 
-## 修复上一节中的`largest`函数
-还记得上一节中的[例子](./generic#泛型详解)吧,当时留下一个疑问，该如何解决编译报错：
+## 修复上一节中的 `largest` 函数
+还记得上一节中的[例子](./generic#泛型详解)吧，当时留下一个疑问，该如何解决编译报错：
 ```rust
-error[E0369]: binary operation `>` cannot be applied to type `T` // 无法在`T`类型上应用`>`运算符
+error[E0369]: binary operation `>` cannot be applied to type `T` // 无法在 `T` 类型上应用`>`运算符
  --> src/main.rs:5:17
   |
 5 |         if item > largest {
@@ -315,13 +315,13 @@ error[E0369]: binary operation `>` cannot be applied to type `T` // 无法在`T`
   |            |
   |            T
   |
-help: consider restricting type parameter `T` // 考虑使用以下的特征来约束T
+help: consider restricting type parameter `T` // 考虑使用以下的特征来约束 `T`
   |
 1 | fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> T {
   |             ^^^^^^^^^^^^^^^^^^^^^^
 ```
 
-在 `largest` 函数体中我们想要使用大于运算符（>）比较两个 `T` 类型的值。这个运算符是标准库中特征 `std::cmp::PartialOrd` 的一个默认方法。所以需要在 `T` 的特征约束中指定 `PartialOrd`，这样 `largest` 函数可以用于内部元素类型可比较大小的数组切片。
+在 `largest` 函数体中我们想要使用大于运算符（`>`）比较两个 `T` 类型的值。这个运算符是标准库中特征 `std::cmp::PartialOrd` 的一个默认方法。所以需要在 `T` 的特征约束中指定 `PartialOrd`，这样 `largest` 函数可以用于内部元素类型可比较大小的数组切片。
 
 由于 `PartialOrd` 位于 `prelude` 中所以并不需要通过 `std::cmp` 手动将其引入作用域。所以可以将 `largest` 的签名修改为如下：
 ```rust
@@ -349,9 +349,9 @@ error[E0507]: cannot move out of borrowed content
   |         cannot move out of borrowed content
 ```
 
-错误的核心是 `cannot move out of type [T], a non-copy slice`， 原因是`T`没有[实现`Copy`特性](../ownership/ownership.md#拷贝(浅拷贝))，因此我们只能把所有权进行转移，毕竟只有`i32`等基础类型才实现了 `Copy` 特性，可以存储在栈上，而 `T` 可以指代任何类型(严格来说是实现了`PartialOrd`特征的所有类型)。
+错误的核心是 `cannot move out of type [T], a non-copy slice`，原因是 `T` 没有[实现 `Copy` 特性](../ownership/ownership.md#拷贝(浅拷贝))，因此我们只能把所有权进行转移，毕竟只有 `i32` 等基础类型才实现了 `Copy` 特性，可以存储在栈上，而 `T` 可以指代任何类型（严格来说是实现了 `PartialOrd` 特征的所有类型）。
 
-因此，为了让T拥有 `Copy` 特性，我们可以增加特征约束：
+因此，为了让 `T` 拥有 `Copy` 特性，我们可以增加特征约束：
 ```rust
 fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
     let mut largest = list[0];
@@ -378,21 +378,21 @@ fn main() {
 }
 ```
 
-如果并不希望限制 `largest` 函数只能用于实现了 `Copy` 特征的类型，我们可以在 `T` 的特征约束中指定 [`Clone`特征](../ownership/ownership.md#克隆(深拷贝)) 而不是 `Copy` 特征。并克隆 `list` 中的每一个值使得 `largest` 函数拥有其所有权。使用 `clone` 函数意味着对于类似 `String` 这样拥有堆上数据的类型，会潜在地分配更多堆上空间，而堆分配在涉及大量数据时可能会相当缓慢。
+如果并不希望限制 `largest` 函数只能用于实现了 `Copy` 特征的类型，我们可以在 `T` 的特征约束中指定 [`Clone` 特征](../ownership/ownership.md#克隆(深拷贝)) 而不是 `Copy` 特征。并克隆 `list` 中的每一个值使得 `largest` 函数拥有其所有权。使用 `clone` 函数意味着对于类似 `String` 这样拥有堆上数据的类型，会潜在地分配更多堆上空间，而堆分配在涉及大量数据时可能会相当缓慢。
 
 另一种 `largest` 的实现方式是返回在 `list` 中 `T` 值的引用。如果我们将函数返回值从 `T` 改为 `&T` 并改变函数体使其能够返回一个引用，我们将不需要任何 `Clone` 或 `Copy` 的特征约束而且也不会有任何的堆分配。尝试自己实现这种替代解决方式吧！
 
 
-## 通过`derive`派生特征
+## 通过 `derive` 派生特征
 在本书中，形如 `#[derive(Debug)]` 的代码已经出现了很多次，这种是一种特征派生语法，被 `derive` 标记的对象会自动实现对应的默认特征代码，继承相应的功能。
 
-例如 `Debug` 特征，它有一套自动实现的默认代码，当你给一个结构体标记后，就可以使用 `println!("{:?}",s)` 的形式打印该结构体的对象。
+例如 `Debug` 特征，它有一套自动实现的默认代码，当你给一个结构体标记后，就可以使用 `println!("{:?}", s)` 的形式打印该结构体的对象。
 
 再如 `Copy` 特征，它也有一套自动实现的默认代码，当标记到一个类型上时，可以让这个类型自动实现 `Copy` 特征，进而可以调用 `copy` 方法，进行自我复制。
 
-总之，`derive` 派生出来的是Rust默认给我们提供的特征，在开发过程中极大的简化了自己手动实现相应特征的需求，当然，如果你有特殊的需求，还可以自己手动重载该实现。
+总之，`derive` 派生出来的是 Rust 默认给我们提供的特征，在开发过程中极大的简化了自己手动实现相应特征的需求，当然，如果你有特殊的需求，还可以自己手动重载该实现。
 
-详细的 `derive` 列表参加[附录-派生特征](../../appendix/derive.md)。
+详细的 `derive` 列表参见[附录-派生特征](../../appendix/derive.md)。
 
 ## 调用方法需要引入特征
 在一些场景中，使用 `as` 关键字做类型转换会有比较大的限制，因为你想要在类型转换上拥有完全的控制，例如处理转换错误，那么你将需要 `TryInto`：
@@ -415,13 +415,13 @@ fn main() {
 
 上面代码中引入了 `std::convert::TryInto` 特征，但是却没有使用它，可能有些同学会为此困惑，主要原因在于**如果你要使用一个特征的方法，那么你需要引入该特征到当前的作用域中**，我们在上面用到了 `try_into` 方法，因此需要引入对应的特征。
 
-但是Rust又提供了一个非常便利的办法，即把最常用的标准库中的特征通过[`std::prelude`](std::convert::TryInto)模块提前引入到当前作用域中，其中包括了 `std::convert::TryInto`，你可以尝试删除第一行的代码 `use ...`，看看是否会报错.
+但是 Rust 又提供了一个非常便利的办法，即把最常用的标准库中的特征通过 [`std::prelude`](std::convert::TryInto) 模块提前引入到当前作用域中，其中包括了 `std::convert::TryInto`，你可以尝试删除第一行的代码 `use ...`，看看是否会报错。
 
 
 ## 几个综合例子
 
-#### 为自定义类型实现`+`操作
-在Rust中除了数值类型的加法，`String` 也可以做[加法](../compound-type/string-slice.md#操作字符串)，因为Rust为该类型实现了 `std::ops::Add` 特征，同理，如果我们为自定义类型实现了该特征，那就可以自己实现 `Point1 + Point2` 的操作: 
+#### 为自定义类型实现 `+` 操作
+在 Rust 中除了数值类型的加法，`String` 也可以做[加法](../compound-type/string-slice.md#操作字符串)，因为 Rust 为该类型实现了 `std::ops::Add` 特征，同理，如果我们为自定义类型实现了该特征，那就可以自己实现 `Point1 + Point2` 的操作: 
 
 ```rust
 use std::ops::Add;
@@ -527,7 +527,7 @@ fn main() {
 ```
 
 
-以上两个例子较为复杂，目的是为读者展示下真实的使用场景长什么样，因此需要读者细细阅读，最终消化这些知识对于你的Rust之路会有莫大的帮助。
+以上两个例子较为复杂，目的是为读者展示下真实的使用场景长什么样，因此需要读者细细阅读，最终消化这些知识对于你的 Rust 之路会有莫大的帮助。
 
 
-最后，特征和特征约束，是Rust中极其重要的概念，如果你还是没搞懂，强烈建议回头再看一遍，或者寻找相关的资料进行补充学习。如果已经觉得掌握了，那么就可以进入下一节的学习。
+最后，特征和特征约束，是 Rust 中极其重要的概念，如果你还是没搞懂，强烈建议回头再看一遍，或者寻找相关的资料进行补充学习。如果已经觉得掌握了，那么就可以进入下一节的学习。