Merge pull request #1528 from LincDocs/branch2

docs:  fix some syntax error

README.md

@@ -45,6 +45,7 @@
 🏆
 
 <table>
+    <tbody>
     <tr>
         <td align="center">
             <a href="https://github.com/EluvK">
@@ -61,6 +62,7 @@
             </a>
         </td>
     </tr>
+    </tbody>
 </table>
 
 <br />
@@ -68,6 +70,7 @@
 🏅
 
 <table>
+    <tbody>
     <tr>
         <td align="center">
             <a href="https://github.com/SUN-LG">
@@ -98,6 +101,7 @@
             </a>
         </td>
     </tr>
+    </tbody>
 </table>
 
 ## 创作感悟

assets/writing-material/posts/hashmap.md

@@ -3,4 +3,4 @@ Any type that implements the Eq and Hash traits can be a key in HashMap.
 
 Note that f32 and f64 do not implement Hash, likely because floating-point precision errors would make using them as hashmap keys horribly error-prone.
 
-All collection classes implement Eq and Hash if their contained type also respectively implements Eq and Hash. For example, Vec<T> will implement Hash if T implements Hash.
+All collection classes implement Eq and Hash if their contained type also respectively implements Eq and Hash. For example, `Vec<T>` will implement Hash if T implements Hash.

src/SUMMARY.md

@@ -93,7 +93,7 @@
     - [Sized 和不定长类型 DST](advance/into-types/sized.md)
     - [枚举和整数](advance/into-types/enum-int.md)
   - [智能指针](advance/smart-pointer/intro.md)
-    - [Box<T>堆对象分配](advance/smart-pointer/box.md)
+    - [Box\<T\> 堆对象分配](advance/smart-pointer/box.md)
     - [Deref 解引用](advance/smart-pointer/deref.md)
     - [Drop 释放资源](advance/smart-pointer/drop.md)
     - [Rc 与 Arc 实现 1vN 所有权机制](advance/smart-pointer/rc-arc.md)

src/about-book.md

@@ -41,6 +41,7 @@ Rust 语言真的好：连续八年成为全世界最受欢迎的语言、没有
 🏆
 
 <table>
+    <tbody>
     <tr>
         <td align="center">
             <a href="https://github.com/EluvK">
@@ -57,6 +58,7 @@ Rust 语言真的好：连续八年成为全世界最受欢迎的语言、没有
             </a>
         </td>
     </tr>
+    </tbody>
 </table>
 
 <br />
@@ -64,6 +66,7 @@ Rust 语言真的好：连续八年成为全世界最受欢迎的语言、没有
 🏅
 
 <table>
+    <tbody>
     <tr>
         <td align="center">
             <a href="https://github.com/JesseAtSZ">
@@ -94,4 +97,5 @@ Rust 语言真的好：连续八年成为全世界最受欢迎的语言、没有
             </a>
         </td>
     </tr>
+    </tbody>
 </table>

src/basic/formatted-output.md

@@ -55,7 +55,7 @@ eprintln!("Error: Could not complete task")
 
 它们仅应该被用于输出错误信息和进度信息，其它场景都应该使用 `print!` 系列。
 
-## {} 与 {:?}
+## `{}` 与 `{:?}`
 
 与其它语言常用的 `%d`，`%s` 不同，Rust 特立独行地选择了 `{}` 作为格式化占位符（说到这个，有点想吐槽下，Rust 中自创的概念其实还挺多的，真不知道该夸奖还是该吐槽-,-），事实证明，这种选择非常正确，它帮助用户减少了很多使用成本，你无需再为特定的类型选择特定的占位符，统一用 `{}` 来替代即可，剩下的类型推导等细节只要交给 Rust 去做。
 
@@ -111,7 +111,7 @@ println!("{}, {}, {}, {}", i, s, v, p);
 
 下面来一一看看这三种方式。
 
-#### {:#?}
+#### `{:#?}`
 
 `{:#?}` 与 `{:?}` 几乎一样，唯一的区别在于它能更优美地输出内容：
 

src/index-list.md

@@ -31,31 +31,31 @@
 
 | 名称                              | 关键字         | 简介                                                                                 |
 | --------------------------------- | -------------- | ------------------------------------------------------------------------------------ |
-| [?]                               | 错误传播       | 用于简化错误传播                                                                     |
+| `[?]`                             | 错误传播       | 用于简化错误传播                                                                     |
-| [()]                              | 单元类型       | 单元类型，无返回值                                                                   |
+| `[()]`                            | 单元类型       | 单元类型，无返回值                                                                   |
 | `!` : 1. [函数] 2. [类型]         | 永不返回       | 永不返回                                                                             |
-| [&]                               | 引用           | 常规引用是一个指针类型，指向了对象存储的内存地址                                     |
+| `[&]`                             | 引用           | 常规引用是一个指针类型，指向了对象存储的内存地址                                     |
-| [\*]                              | 解引用         | 解出引用所指向的值                                                                   |
+| `[\*]`                            | 解引用         | 解出引用所指向的值                                                                   |
-| [@]                               | 变量绑定       | 为一个字段绑定另外一个变量                                                           |
+| `[@]`                             | 变量绑定       | 为一个字段绑定另外一个变量                                                           |
 | `_` : 1. [忽略变量] 2. [模式匹配] | 忽略           | 1. 忽略该值或者类型，否则编译器会给你一个 `变量未使用的` 的警告<br>2. 模式匹配通配符 |
-| ['a: 'b]                          | 生命周期约束   | 用来说明两个生命周期的长短                                                           |
+| `['a: 'b]`                        | 生命周期约束   | 用来说明两个生命周期的长短                                                           |
-| [{:?}] {:#?}                      | 打印结构体信息 | 使用 `#[derive(Debug)]` 派生实现 `Debug` 特征，另见 [格式化输出]                     |
+| `[{:?}] {:#?}`                    | 打印结构体信息 | 使用 `#[derive(Debug)]` 派生实现 `Debug` 特征，另见 [格式化输出]                     |
-| [::]                              | 关联函数       | 定义在 `impl` 中且没有 `self` 的函数                                                 |
+| `[::]`                            | 关联函数       | 定义在 `impl` 中且没有 `self` 的函数                                                 |
 |                                   |                |
 
-[?]: https://course.rs/basic/result-error/result.html#传播界的大明星-
+`[?]`: https://course.rs/basic/result-error/result.html#传播界的大明星-
-[()]: https://course.rs/basic/base-type/function.html#无返回值
+`[()]`: https://course.rs/basic/base-type/function.html#无返回值
-[函数]: https://course.rs/basic/base-type/function.html#永不返回的发散函数-
+`[函数]`: https://course.rs/basic/base-type/function.html#永不返回的发散函数-
-[类型]: https://course.rs/advance/into-types/custom-type.html#永不返回类型
+`[类型]`: https://course.rs/advance/into-types/custom-type.html#永不返回类型
-[&]: https://course.rs/basic/ownership/borrowing.html#引用与解引用
+`[&]`: https://course.rs/basic/ownership/borrowing.html#引用与解引用
-[\*]: https://course.rs/basic/ownership/borrowing.html#引用与解引用
+`[\*]`: https://course.rs/basic/ownership/borrowing.html#引用与解引用
-[@]: https://course.rs/basic/match-pattern/all-patterns.html#绑定
+`[@]`: https://course.rs/basic/match-pattern/all-patterns.html#绑定
-['a: 'b]: https://course.rs/advance/lifetime/advance.html#生命周期约束-hrtb
+`['a: 'b]`: https://course.rs/advance/lifetime/advance.html#生命周期约束-hrtb
-[{:?}]: https://course.rs/basic/compound-type/struct.html#使用-derivedebug-来打印结构体的信息
+`[{:?}]`: https://course.rs/basic/compound-type/struct.html#使用-derivedebug-来打印结构体的信息
-[忽略变量]: https://course.rs/basic/variable.html#使用下划线开头忽略未使用的变量
+`[忽略变量]`: https://course.rs/basic/variable.html#使用下划线开头忽略未使用的变量
-[模式匹配]: https://course.rs/basic/match-pattern/match-if-let.html#_-通配符
+`[模式匹配]`: https://course.rs/basic/match-pattern/match-if-let.html#_-通配符
-[::]: https://course.rs/basic/method.html#关联函数
+`[::]`: https://course.rs/basic/method.html#关联函数
-[格式化输出]: https://course.rs/basic/formatted-output.html#-与-
+`[格式化输出]`: https://course.rs/basic/formatted-output.html#-与-
 
 [back](#head)
 

src/profiling/compiler/phantom-data.md

@@ -59,7 +59,7 @@ struct Vec<T> {
 让裸指针拥有数据是一个很普遍的设计，以至于标准库为它自己创造了一个叫`Unique<T>`的组件，它可以：
 
 - 封装一个`*const T`处理变性
-- 包含一个PhantomData<T>
+- 包含一个 `PhantomData<T>`
 - 自动实现`Send`/`Sync`，模拟和包含T时一样的行为
 - 将指针标记为`NonZero`以便空指针优化
 

src/too-many-lists/production-unsafe-deque/basics.md

@@ -1,6 +1,6 @@
 # Basics
 
-好了，这就是本书最烂的部分，也是我花了 7 年时间才写完这一章的原因！是时候把我们已经做过 5 次的枯燥乏味的东西再写一遍了，但因为我们必须使用 Option<NonNull<Node<T>> 把每件事都做两遍，所以显得格外冗长！
+好了，这就是本书最烂的部分，也是我花了 7 年时间才写完这一章的原因！是时候把我们已经做过 5 次的枯燥乏味的东西再写一遍了，但因为我们必须使用 `Option<NonNull<Node<T>>` 把每件事都做两遍，所以显得格外冗长！
 
 ```rust
 impl<T> LinkedList<T> {

src/too-many-lists/production-unsafe-deque/implementing-cursors.md

@@ -216,7 +216,7 @@ pub fn split_before(&mut self) -> LinkedList<T> {
 }
 ```
 
-你可能注意到，我们没有处理 prev 是幽灵节点的情况。但据我所知，其他一切都只是顺便做了正确的事。等我们写测试的时候就知道了！(复制粘贴完成 split_after）。
+你可能注意到，我们没有处理 prev 是幽灵节点的情况。但据我所知，其他一切都只是顺便做了正确的事。等我们写测试的时候就知道了！（复制粘贴完成 split_after）。
 
 # [Splice](https://rust-unofficial.github.io/too-many-lists/sixth-cursors-impl.html#splice)
 
@@ -297,7 +297,7 @@ list.front -> A <-> 1 <-> 2 <-> B <-> C <- list.back
     }
 ```
 
-好吧，这个程序真的很可怕，现在真的感觉到 Option<NonNull> 的痛苦了。但我们可以做很多清理工作。首先，我们可以把这段代码拖到最后。
+好吧，这个程序真的很可怕，现在真的感觉到 `Option<NonNull>` 的痛苦了。但我们可以做很多清理工作。首先，我们可以把这段代码拖到最后。
 
 ```rust
 self.list.len += input.len;

src/too-many-lists/production-unsafe-deque/variance-and-phantomData.md

@@ -120,7 +120,7 @@ Rust 中的裸指针其实就是让你可以做任何事情，但它们只有一
 
 作为一个花了大量时间在 Rust 中编写集合的人，这让我感到厌烦。这就是为什么我在制作 [std::ptr::NonNull](https://doc.rust-lang.org/std/ptr/struct.NonNull.html), 时添加了这个小魔法：
 
-> 与 *mut T 不同，NonNull<T> 在 T 上是 *covariant(协变的)*。这使得使用 NonNull<T> 构建*covariant(协变的)*类型成为可能，但如果在不应该是 *covariant(协变的)* 的地方中使用，则会带来不健全的风险。
+> 与 *mut T 不同，`NonNull<T>` 在 T 上是 *covariant(协变的)*。这使得使用 `NonNull<T>` 构建*covariant(协变的)*类型成为可能，但如果在不应该是 *covariant(协变的)* 的地方中使用，则会带来不健全的风险。
 
 这是一个围绕着 `*mut T` 构建的类型。真的是魔法吗？让我们来看一下：
 
@@ -140,7 +140,7 @@ impl<T> NonNull<T> {
 
 不，这里没有魔法！NonNull 只是滥用了 *const T 是 *covariant(协变的)* 这一事实，并将其存储起来。这就是 Rust 中集合的协变方式！这可真是惨不忍睹！所以我为你做了这个 Good Pointer Type ！不客气好好享受子类型吧
 
-解决你所有问题的办法就是使用 NonNull，然后如果你想再次使用可空指针，就使用 Option<NonNull<T>>。我们真的要这么做吗？
+解决你所有问题的办法就是使用 NonNull，然后如果你想再次使用可空指针，就使用 `Option<NonNull<T>>`。我们真的要这么做吗？
 
 是的！这很糟糕，但我们要做的是生产级的链表，所以我们要吃尽千辛万苦（我们可以直接使用裸*const T，然后在任何地方都进行转换，但我真的想看看这样做有多痛苦......为了人体工程学科学）。