Merge pull request #4 from sunface/main

sync

README.md

@@ -4,13 +4,10 @@
   - 官方： [https://course.rs](https://course.rs)
   - 知乎： [支持章节内目录跳转，很好用!](https://www.zhihu.com/column/c_1452781034895446017)
   
-- Rust语言社区: QQ群 1009730433
+- 本书配套项目  
-  
+  - [Rust By Practice](https://github.com/sunface/rust-by-practice)，它是本书的配套练习册，提供了大量有挑战性的示例、练习和实践项目，帮助大家解决 Rust 语言从学习到实战的问题 — 毕竟这之间还隔着好几个 Go 语言的难度 :D
-> 学习 Rust 光看书不够，精心设计的习题和项目实践可以让你事半功倍。[Rust By Practice](https://github.com/sunface/rust-by-practice) 是本书的配套习题和实践，覆盖了 easy to hard 各个难度，满足大家对 Rust 的所有期待。
+  - [Rust 语言周刊](https://github.com/sunface/rust-weekly)，每周一发布，精选过去一周的技术文章、业界新闻、开源项目和 Rust 语言动态
-> 
+  - [Fancy Rust](https://github.com/sunface/fancy-rust) Rust 优秀项目很多，如何在茫茫码海中与它们相遇？相比 Awesome Rust，它能带给你全新的体验和选择
-> [Rust 语言周刊](https://github.com/sunface/rust-weekly)，每周一发布，精选过去一周的技术文章、业界新闻、开源项目和 Rust 语言动态。
->
-> Rust 优秀项目很多，如何在茫茫码海中与它们相遇？相比 Awesome Rust， [Fancy Rust](https://github.com/sunface/fancy-rust) 能带给你全新的体验和选择。
 
 
 ## 教程简介

src/SUMMARY.md

@@ -164,6 +164,10 @@
       - [定义 Peek 函数](too-many-lists/ok-stack/peek.md)
       - [IntoIter 和 Iter](too-many-lists/ok-stack/iter.md)
       - [IterMut以及完整代码](too-many-lists/ok-stack/itermut.md)
+    - [持久化单向链表](too-many-lists/persistent-stack/intro.md)
+      - [数据布局和基本操作](too-many-lists/persistent-stack/layout.md)
+      - [Drop、Arc 及完整代码](too-many-lists/persistent-stack/drop-arc.md)
+
 - [易混淆概念解析](confonding/intro.md)
   - [切片和切片引用](confonding/slice.md)
   - [Eq 和 PartialEq](confonding/eq.md)
@@ -185,7 +189,6 @@
   - [类型未限制(todo)](fight-with-compiler/unconstrained.md)
 
 - [Rust 常见陷阱](pitfalls/index.md)
-
   - [for 循环中使用外部数组](pitfalls/use-vec-in-for.md)
   - [线程类型导致的栈溢出](pitfalls/stack-overflow.md)
   - [算术溢出导致的 panic](pitfalls/arithmetic-overflow.md)
@@ -196,6 +199,7 @@
   - [奇怪的序列 x..y](pitfalls/weird-ranges.md)
   - [无处不在的迭代器](pitfalls/iterator-everywhere.md)
   - [线程间传递消息导致主线程无法结束](pitfalls/main-with-channel-blocked.md)
+  - [警惕 UTF-8 引发的性能隐患](pitfalls/utf8-performance.md)
 
 - [Rust 最佳实践 doing](practice/intro.md)
   - [日常开发三方库精选](practice/third-party-libs.md)

src/cargo/guide/build-cache.md

@@ -15,7 +15,7 @@
 | 目录             | 描述                                                                    |
 | ---------------- | ----------------------------------------------------------------------- |
 | `target/debug/`  | 包含了 `dev` profile 的构建输出(`cargo build` 或 `cargo build --debug`) |
-| `target/release` | `release` profile 的构建输出，`cargo build --release`                   |
+| `target/release/` | `release` profile 的构建输出，`cargo build --release`                   |
 | `target/foo/`    | 自定义 `foo` profile 的构建输出，`cargo build --profile=foo`            |
 
 出于历史原因:
@@ -30,7 +30,7 @@
 
 | 目录                       | 示例                                    |
 | -------------------------- | --------------------------------------- |
-| `target/<triple>/debug`    | `target/thumbv7em-none-eabihf/debug/`   |
+| `target/<triple>/debug/`    | `target/thumbv7em-none-eabihf/debug/`   |
 | `target/<triple>/release/` | `target/thumbv7em-none-eabihf/release/` |
 
 > **注意：**，当没有使用 `--target` 时，`Cargo` 会与构建脚本和过程宏一起共享你的依赖包，对于每个 `rustc` 命令调用而言，[`RUSTFLAGS`](https://course.rs/cargo/reference/configuration.html#配置文件概览) 也将被共享。

src/index-list.md

@@ -83,9 +83,12 @@
 
 ## F
 
-| 名称 | 关键字 | 简介          |
+| 名称     | 关键字   | 简介                       |
-| ---- | ------ | ------------- |
+| -------- | -------- | -------------------------- |
-| F    | KWF    | FIntroduction |
+| [浮点数] | 数值类型 | `f32` <br> `f64`(默认类型) |
+| F        | KWF      | FIntroduction              |
+
+[浮点数]: https://course.rs/basic/base-type/numbers.html#浮点类型
 
 [back](#head)
 
@@ -192,9 +195,14 @@
 
 ## S
 
-| 名称 | 关键字 | 简介          |
+| 名称         | 关键字   | 简介                                                                                                   |
-| ---- | ------ | ------------- |
+| ------------ | -------- | ------------------------------------------------------------------------------------------------------ |
-| S    | KWS    | SIntroduction |
+| [整数]       | 数值类型 | 有符号整数，`i8`,`i16`,`i32`,`i64`,`i128`,`isize`<br>无符号整数，`u8`,`u16`,`u32`,`u64`,`u128`,`usize` |
+| [整形字面量] | 进制书写 | 十进制 `98_222`<br>十六进制 `0xff`<br>八进制 `0o77`<br>二进制 `0b1111_0000`<br>字节(仅限于`u8`) `b'A'` |
+| S            | KWS      | SIntroduction                                                                                          |
+
+[整数]: https://course.rs/basic/base-type/numbers.html#整数类型
+[整形字面量]: https://course.rs/basic/base-type/numbers.html#整数类型
 
 [back](#head)
 
@@ -232,9 +240,12 @@
 
 ## X
 
-| 名称 | 关键字 | 简介          |
+| 名称   | 关键字 | 简介                                                                               |
-| ---- | ------ | ------------- |
+| ------ | ------ | ---------------------------------------------------------------------------------- |
-| X    | KWX    | XIntroduction |
+| [序列] | Range  | 生成连续的数值<br> 只允许用于数字或字符类型<br> `..` 右半开区间 <br>`..=` 闭合区间 |
+| X      | KWX    | XIntroduction                                                                      |
+
+[序列]: https://course.rs/basic/base-type/numbers.html#序列range
 
 [back](#head)
 

src/into-rust.md

@@ -159,4 +159,4 @@ Rust 语言表达能力更强，性能更高。同时线程安全方面 Rust 也
 
 > 本书是完全开源的，但是并不意味着质量上的妥协，这里的每一个章节都花费了大量的心血和时间才能完成，为此牺牲了陪伴家人、日常娱乐的时间，虽然我们并不后悔，但是如果能得到读者您的鼓励，我们将感激不尽。
 >
-> 既然是开源，那最大的鼓励不是 money，而是 star:) **如果大家觉得这本书作者真的用心了，就帮我们[点一个 🌟 ](https;//github.com/sunface/rust-course)吧，这将是我们继续前行最大的动力**
+> 既然是开源，那最大的鼓励不是 money，而是 star:) **如果大家觉得这本书作者真的用心了，就帮我们[点一个 🌟 ](https://github.com/sunface/rust-course)吧，这将是我们继续前行最大的动力**

src/pitfalls/utf8-performance.md

@@ -0,0 +1,36 @@
+# 警惕 UTF-8 引发的性能隐患
+大家应该都知道, 虽然 Rust 的字符串 `&str`、`String` 在底层是通过 `Vec<u8>` 实现的：字符串数据以字节数组的形式存在堆上，但在使用时，它们都是 UTF-8 编码的，例如:
+```rust
+fn main() {
+    let s: &str = "中国人";
+    for c in s.chars() {
+        println!("{}", c) // 依次输出：中 、 国 、 人
+    }
+
+    let c = &s[0..3]; // 1. "中" 在 UTF-8 中占用 3 个字节 2. Rust 不支持字符串索引，因此只能通过切片的方式获取 "中"
+    assert_eq!(c, "中");
+}
+```
+
+从上述代码，可以很清晰看出，Rust 的字符串确实是 UTF-8 编码的，这就带来一个隐患：可能在某个转角，你就会遇到来自糟糕性能的示爱。
+
+## 问题描述 & 解决
+例如我们尝试写一个词法解析器，里面用到了以下代码 `self.source.chars().nth(self.index).unwrap();` 去获取下一个需要处理的字符，大家可能会以为 `.nth` 的访问应该非常快吧？事实上它确实很快，但是并不妨碍这段代码在循环处理 70000 长度的字符串时，需要消耗 5s 才能完成！
+
+这么看来，唯一的问题就在于 `.chars()` 上了。
+
+其实原因很简单，简单到我们不需要用代码来说明，只需要文字描述即可传达足够的力量：每一次循环时，`.chars().nth(index)` 都需要对字符串进行一次 UTF-8 解析，这个解析实际上是相当昂贵的，特别是当配合循环时，算法的复杂度就是平方级的。
+
+既然找到原因，那解决方法也很简单：只要将 `self.source.chars()` 的迭代器存储起来就行，这样每次 `.nth` 调用都会复用已经解析好的迭代器，而不是重新去解析一次 UTF-8 字符串。
+
+当然，我们还可以使用三方库来解决这个问题，例如 [str_indices](https://crates.io/crates/str_indices)。
+
+## 总结
+最终的优化结果如下：
+
+- 保存迭代器后: 耗时 `5s` -> `4ms`
+- 进一步使用 `u8` 字节数组来替换 `char`，最后使用 `String::from_utf8` 来构建 UTF-8 字符串: 耗时 `4ms` -> `400us`
+
+**肉眼可见的巨大提升，12500 倍！** 
+
+总之，我们在热点路径中使用字符串做 UTF-8 的相关操作时，就算不提前优化，也要做到心里有数，这样才能在问题发生时，进退自如。

src/too-many-lists/persistent-stack/drop-arc.md

@@ -0,0 +1,189 @@
+# Drop、Arc 及完整代码
+
+## Drop
+与之前链表存在的问题相似，新的链表也有递归的问题。下面是之前的解决方法:
+```rust
+impl<T> Drop for List<T> {
+    fn drop(&mut self) {
+        let mut cur_link = self.head.take();
+        while let Some(mut boxed_node) = cur_link {
+            cur_link = boxed_node.next.take();
+        }
+    }
+}
+```
+
+但是 `boxed_node.next.take()` 的方式在新的链表中无法使用，因为我们没办法去修改 `Rc` 持有的值。
+
+考虑一下相关的逻辑，可以发现，如果当前的节点仅被当前链表所引用(Rc 的引用计数为 1)，那该节点是可以安全 `drop` 的: 
+```rust
+impl<T> Drop for List<T> {
+    fn drop(&mut self) {
+        let mut head = self.head.take();
+        while let Some(node) = head {
+            if let Ok(mut node) = Rc::try_unwrap(node) {
+                head = node.next.take();
+            } else {
+                break;
+            }
+        }
+    }
+}
+```
+
+这里有一个没见过的方法 `Rc::Try_unwrap` ，该方法会判断当前的 `Rc` 是否只有一个强引用，若是，则返回 `Rc` 持有的值，否则返回一个错误。
+
+可以看出，我们会一直 drop 到第一个被其它链表所引用的节点：
+```shell
+list1 -> A ---+
+              |
+              v
+list2 ------> B -> C -> D
+              ^
+              |
+list3 -> X ---+
+```
+
+例如如果要 drop `List2`，那会从头节点开始一直 drop 到 `B` 节点时停止，剩余的 `B -> C -> D` 三个节点由于引用计数不为 1 (同时被多个链表引用) ，因此不会被 drop。
+
+
+测试下新的代码:
+```shell
+cargo test
+   Compiling lists v0.1.0 (/Users/ABeingessner/dev/too-many-lists/lists)
+    Finished dev [unoptimized + debuginfo] target(s) in 1.10s
+     Running /Users/ABeingessner/dev/too-many-lists/lists/target/debug/deps/lists-86544f1d97438f1f
+
+running 8 tests
+test first::test::basics ... ok
+test second::test::basics ... ok
+test second::test::into_iter ... ok
+test second::test::iter ... ok
+test second::test::iter_mut ... ok
+test second::test::peek ... ok
+test third::test::basics ... ok
+test third::test::iter ... ok
+
+test result: ok. 8 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out
+```
+
+完美通过，下面再来考虑一个问题，如果我们的链表要在多线程环境使用该怎么办？
+
+## Arc
+不可变链表的一个很大的好处就在于多线程访问时自带安全性，毕竟共享可变性是多线程危险的源泉，最好也是最简单的解决办法就是直接干掉可变性。
+
+但是 `Rc<T>` 本身并不是线程安全的，原因在之前的章节也有讲：它内部的引用计数器并不是线程安全的，通俗来讲，计数器没有加锁也没有实现原子性。
+
+再结合之前章节学过的内容，绝大部分同学应该都能想到, `Arc<T>` 就是我们的最终答案。
+
+那么还有一个问题，我们怎么知道一个类型是不是类型安全？会不会在多线程误用了非线程安全的类型呢？这就是 Rust 安全性的另一个强大之处：Rust 通过提供 `Send` 和 `Sync` 两个特征来保证线程安全。
+
+> 关于 `Send` 和 `Sync` 的详细介绍，请参见[此章节](https://course.rs/advance/concurrency-with-threads/send-sync.html)
+
+## 完整代码
+又到了喜闻乐见的环节，新链表的代码相比之前反而还更简单了，不可变就是香！
+
+```rust
+use std::rc::Rc;
+
+pub struct List<T> {
+    head: Link<T>,
+}
+
+type Link<T> = Option<Rc<Node<T>>>;
+
+struct Node<T> {
+    elem: T,
+    next: Link<T>,
+}
+
+impl<T> List<T> {
+    pub fn new() -> Self {
+        List { head: None }
+    }
+
+    pub fn prepend(&self, elem: T) -> List<T> {
+        List { head: Some(Rc::new(Node {
+            elem: elem,
+            next: self.head.clone(),
+        }))}
+    }
+
+    pub fn tail(&self) -> List<T> {
+        List { head: self.head.as_ref().and_then(|node| node.next.clone()) }
+    }
+
+    pub fn head(&self) -> Option<&T> {
+        self.head.as_ref().map(|node| &node.elem)
+    }
+
+    pub fn iter(&self) -> Iter<'_, T> {
+        Iter { next: self.head.as_deref() }
+    }
+}
+
+impl<T> Drop for List<T> {
+    fn drop(&mut self) {
+        let mut head = self.head.take();
+        while let Some(node) = head {
+            if let Ok(mut node) = Rc::try_unwrap(node) {
+                head = node.next.take();
+            } else {
+                break;
+            }
+        }
+    }
+}
+
+pub struct Iter<'a, T> {
+    next: Option<&'a Node<T>>,
+}
+
+impl<'a, T> Iterator for Iter<'a, T> {
+    type Item = &'a T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.next.map(|node| {
+            self.next = node.next.as_deref();
+            &node.elem
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::List;
+
+    #[test]
+    fn basics() {
+        let list = List::new();
+        assert_eq!(list.head(), None);
+
+        let list = list.prepend(1).prepend(2).prepend(3);
+        assert_eq!(list.head(), Some(&3));
+
+        let list = list.tail();
+        assert_eq!(list.head(), Some(&2));
+
+        let list = list.tail();
+        assert_eq!(list.head(), Some(&1));
+
+        let list = list.tail();
+        assert_eq!(list.head(), None);
+
+        // Make sure empty tail works
+        let list = list.tail();
+        assert_eq!(list.head(), None);
+    }
+
+    #[test]
+    fn iter() {
+        let list = List::new().prepend(1).prepend(2).prepend(3);
+
+        let mut iter = list.iter();
+        assert_eq!(iter.next(), Some(&3));
+        assert_eq!(iter.next(), Some(&2));
+        assert_eq!(iter.next(), Some(&1));
+    }
+}
+```

src/too-many-lists/persistent-stack/intro.md

@@ -0,0 +1,15 @@
+# 持久化单向链表
+迄今为止，我们已经掌握了如何实现一个可变的单向链表。但是之前的链表都是单所有权的，在实际使用中，共享所有权才是更实用的方式，下面一起来看看该如何实现一个不可变的、共享所有权的持久化链表( persistent )。
+
+开始之前，还需要创建一个新文件 `third.rs` ，并在 `lib.rs` 中添加以下内容:
+```rust
+// in lib.rs
+
+pub mod first;
+pub mod second;
+pub mod third;
+```
+
+与上一个链表有所不同，这次我们无需拷贝之前的代码，而是从零开始构建一个新的链表。
+
+

src/too-many-lists/persistent-stack/layout.md

@@ -0,0 +1,232 @@
+# 数据布局和基本操作
+对于新的链表来说，最重要的就是我们可以免费的操控列表的尾部( tail )。
+
+## 数据布局
+例如以下是一个不太常见的持久化列表布局:
+```shell
+list1 = A -> B -> C -> D
+list2 = tail(list1) = B -> C -> D
+list3 = push(list2, X) = X -> B -> C -> D
+```
+
+如果上面的不够清晰，我们还可以从内存角度来看：
+```shell
+list1 -> A ---+
+              |
+              v
+list2 ------> B -> C -> D
+              ^
+              |
+list3 -> X ---+
+```
+
+这里大家可能会看出一些端倪：节点 `B` 被多个链表所共享，这造成了我们无法通过 `Box` 的方式来实现，因为如果使用 `Box`，还存在一个问题，谁来负责清理释放？如果 drop `list2`，那 `B` 节点会被清理释放吗？
+
+函数式语言或者说其它绝大多数语言，并不存在这个问题，因为 GC 垃圾回收解千愁，但是 Rust 并没有。
+
+好在标准库为我们提供了引用计数的数据结构: `Rc / Arc`，引用计数可以被认为是一种简单的 GC，对于很多场景来说，引用计数的数据吞吐量要远小于垃圾回收，而且引用计数还存在循环引用的风险！但... 我们有其它选择吗？ :(
+
+不过使用 Rc 意味着我们的数据将无法被改变，因为它不具备内部可变性，关于 Rc/Arc 的详细介绍请看[这里](https://course.rs/advance/smart-pointer/rc-arc.html)。
+
+下面，简单的将我们的数据结构通过 `Rc` 来实现：
+```rust
+// in third.rs
+use std::rc::Rc;
+
+pub struct List<T> {
+    head: Link<T>,
+}
+
+type Link<T> = Option<Rc<Node<T>>>;
+
+struct Node<T> {
+    elem: T,
+    next: Link<T>,
+}
+```
+
+需要注意的是, `Rc` 在 Rust 中并不是一等公民，它没有被包含在 `std::prelude` 中，因此我们必须手动引入 `use std::rc::Rc` (混得好失败 - , -)
+
+## 基本操作
+首先，对于 List 的构造器，可以直接复制粘贴:
+```rust
+impl<T> List<T> {
+    pub fn new() -> Self {
+        List { head: None }
+    }
+}
+```
+
+而之前的 `push` 和 `pop` 已无任何意义，因为新链表是不可变的，但我们可以使用功能相似的 `prepend` 和 `tail` 来返回新的链表。
+
+```rust
+pub fn prepend(&self, elem: T) -> List<T> {
+    List { head: Some(Rc::new(Node {
+        elem: elem,
+        next: self.head.clone(),
+    }))}
+}
+```
+
+大家可能会大惊失色，什么，你竟然用了 `clone`，不是号称高性能链表实现吗？别急，这里其实只是 `Rc::clone`，对于该方法而言，`clone` 仅仅是增加引用计数，并不是复制底层的数据。虽然 `Rc` 的性能要比 `Box` 的引用方式低一点，但是它依然是多所有权前提下最好的解决方式或者说之一。
+
+还有一点值得注意， `head` 是 `Option<Rc<Node<T>>>` 类型，那么为何不先匹配出内部的 `Rc<Node<T>>`，然后再 clone 呢？原因是 `Option` 也提供了相应的 API，它的功能跟我们的需求是一致的。
+
+运行下试试：
+```shell
+> cargo build
+
+warning: field is never used: `elem`
+  --> src/third.rs:10:5
+   |
+10 |     elem: T,
+   |     ^^^^^^^
+   |
+   = note: #[warn(dead_code)] on by default
+
+warning: field is never used: `next`
+  --> src/third.rs:11:5
+   |
+11 |     next: Link<T>,
+   |     ^^^^^^^^^^^^^
+```
+
+胆战心惊的编译通过(胆战心惊? 日常基本操作，请坐下!)。
+
+继续来实现 `tail`，该方法会将现有链表的首个元素移除，并返回剩余的链表:
+```rust
+pub fn tail(&self) -> List<T> {
+    List { head: self.head.as_ref().map(|node| node.next.clone()) }
+}
+```
+
+```shell
+cargo build
+
+error[E0308]: mismatched types
+  --> src/third.rs:27:22
+   |
+27 |         List { head: self.head.as_ref().map(|node| node.next.clone()) }
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected struct `std::rc::Rc`, found enum `std::option::Option`
+   |
+   = note: expected type `std::option::Option<std::rc::Rc<_>>`
+              found type `std::option::Option<std::option::Option<std::rc::Rc<_>>>`
+```
+
+看起来这里的 `map` 多套了一层 `Option`，可以用 `and_then` 替代：
+```rust
+pub fn tail(&self) -> List<T> {
+    List { head: self.head.as_ref().and_then(|node| node.next.clone()) }
+}
+```
+
+顺利通过编译，很棒！最后就是实现 `head` 方法，它返回首个元素的引用，跟之前链表的 `peek` 方法一样:
+```rust
+pub fn head(&self) -> Option<&T> {
+    self.head.as_ref().map(|node| &node.elem )
+}
+```
+
+好了，至此，新链表的基本操作都已经实现，最后让我们写几个测试用例来看看它们是骡子还是马：
+```rust
+#[cfg(test)]
+mod test {
+    use super::List;
+
+    #[test]
+    fn basics() {
+        let list = List::new();
+        assert_eq!(list.head(), None);
+
+        let list = list.prepend(1).prepend(2).prepend(3);
+        assert_eq!(list.head(), Some(&3));
+
+        let list = list.tail();
+        assert_eq!(list.head(), Some(&2));
+
+        let list = list.tail();
+        assert_eq!(list.head(), Some(&1));
+
+        let list = list.tail();
+        assert_eq!(list.head(), None);
+
+        // Make sure empty tail works
+        let list = list.tail();
+        assert_eq!(list.head(), None);
+
+    }
+}
+```
+
+```shell
+> cargo test
+
+     Running target/debug/lists-5c71138492ad4b4a
+
+running 5 tests
+test first::test::basics ... ok
+test second::test::into_iter ... ok
+test second::test::basics ... ok
+test second::test::iter ... ok
+test third::test::basics ... ok
+
+test result: ok. 5 passed; 0 failed; 0 ignored; 0 measured
+```
+
+哦对了... 我们好像忘了一个重要特性：对链表的迭代。
+
+```rust
+pub struct Iter<'a, T> {
+    next: Option<&'a Node<T>>,
+}
+
+impl<T> List<T> {
+    pub fn iter(&self) -> Iter<'_, T> {
+        Iter { next: self.head.as_deref() }
+    }
+}
+
+impl<'a, T> Iterator for Iter<'a, T> {
+    type Item = &'a T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.next.map(|node| {
+            self.next = node.next.as_deref();
+            &node.elem
+        })
+    }
+}
+```
+
+```rust
+#[test]
+fn iter() {
+    let list = List::new().prepend(1).prepend(2).prepend(3);
+
+    let mut iter = list.iter();
+    assert_eq!(iter.next(), Some(&3));
+    assert_eq!(iter.next(), Some(&2));
+    assert_eq!(iter.next(), Some(&1));
+}
+```
+
+```shell
+cargo test
+
+     Running target/debug/lists-5c71138492ad4b4a
+
+running 7 tests
+test first::test::basics ... ok
+test second::test::basics ... ok
+test second::test::iter ... ok
+test second::test::into_iter ... ok
+test second::test::peek ... ok
+test third::test::basics ... ok
+test third::test::iter ... ok
+
+test result: ok. 6 passed; 0 failed; 0 ignored; 0 measured
+```
+
+细心的同学可能会觉得我在凑字数，这不跟之前的链表迭代实现一样一样的嘛？恭喜你答对了 ：）
+
+最后，给大家留个作业，你可以尝试下看能不能实现 `IntoIter` 和 `IterMut`，如果实现不了请不要打我，冤有头债有主，都是 `Rc` 惹的祸 :(

内容变更记录.md

@@ -1,6 +1,12 @@
 # ChangeLog
 记录一些值得注意的变更。
 
+## 2022-03-14
+
+- 新增章节: [Rust 陷阱 - UTF-8 引发的性能隐患](https://course.rs/pitfalls/utf8-performance.html)
+- 新增章节：[持久化链表 - 数据布局和基本操作](https://course.rs/too-many-lists/persistent-stack/layout.html)
+- 新增章节：[持久化链表 - Drop、Arc 及完整代码](https://course.rs/too-many-lists/persistent-stack/drop-arc.html)
+  
 ## 2022-03-13
 
 - 新增章节: [还 OK 的单向链表 - IterMut](https://course.rs/too-many-lists/ok-stack/itermut.html)