Merge pull request #20 from sunface/main

sync
3 years ago · 576eb1ccff
parent 540bf7e72e 5d016f31ef
commit 576eb1ccff
4 changed files with 216 additions and 131 deletions
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@ -5,13 +5,16 @@
 [快速查询入口](index-list.md)

 ---
+
 [Rust 语言中文网](community.md)
 [一本生锈的书](rusty-book.md)
 [Rust 语言周刊](rust-weekly.md)
 [Rust 翻译计划( 代号 Rustt )](rustt.md)

 # 快速开始
+
 ---
+
 - [寻找牛刀，以便小试](first-try/intro.md)
  - [安装 Rust 环境](first-try/installation.md)
  - [墙推 VSCode!](first-try/editor.md)
@ -20,9 +23,12 @@
  - [下载依赖太慢了？](first-try/slowly-downloading.md)
  - [避免从入门到放弃](first-try/sth-you-should-not-do.md)

-# Rust语言学习
+# Rust 语言学习
+
 ---
+
 - [Rust 基础入门](basic/intro.md)
+
  - [变量绑定与解构](basic/variable.md)
  - [基本类型](basic/base-type/index.md)
    - [数值类型](basic/base-type/numbers.md)
@ -65,6 +71,7 @@
  - [格式化输出](basic/formatted-output.md)

 - [Rust 高级进阶](advance/intro.md)
+
  - [生命周期](advance/lifetime/intro.md)
    - [认识生命周期](advance/lifetime/basic.md)
    - [深入生命周期](advance/lifetime/advance.md)
@ -104,6 +111,7 @@
    <!-- - [高阶特征约束(HRTB) todo](advance/hrtb.md) -->

 - [Rust 异步编程](async-rust/intro.md)
+
  - [async/await 异步编程](async-rust/async/intro.md)
    - [async 编程入门](async-rust/async/getting-started.md)
    - [底层探秘: Future 执行与任务调度](async-rust/async/future-excuting.md)
@ -126,7 +134,6 @@
    - [优雅的关闭](async-rust/tokio/graceful-shutdown.md)
    - [异步跟同步共存](async-rust/tokio/bridging-with-sync.md)

-
 - [Rust 难点攻关](difficulties/intro.md)
  - [切片和切片引用](difficulties/slice.md)
  - [Eq 和 PartialEq](difficulties/eq.md)
@ -135,11 +142,12 @@
  - [move、Copy 和 Clone TODO](difficulties/move-copy.md)
  - [裸指针、引用和智能指针 TODO](advance/difficulties/pointer.md)

-  
-
 # 常用工具链
+
 ---
+
 - [自动化测试](test/intro.md)
+
  - [编写测试及控制执行](test/write-tests.md)
  - [单元测试和集成测试](test/unit-integration-test.md)
  - [断言 assertion](test/assertion.md)
@ -172,63 +180,66 @@
      - [构建脚本示例](cargo/reference/build-script/examples.md)

 # 开发实践
+
 ---
+
 - [企业落地实践](usecases/intro.md)
+
  - [AWS 为何这么喜欢 Rust?](usecases/aws-rust.md)

 - [日志和监控](logs/intro.md)
-    - [日志详解](logs/about-log.md)
-    - [日志门面 log](logs/log.md)
-    - [使用 tracing 记录日志](logs/tracing.md)
-    - [自定义 tracing 的输出格式](logs/tracing-logger.md)
-    - [监控](logs/observe/intro.md)
-      - [可观测性](logs/observe/about-observe.md)
-      - [分布式追踪](logs/observe/trace.md)
+  - [日志详解](logs/about-log.md)
+  - [日志门面 log](logs/log.md)
+  - [使用 tracing 记录日志](logs/tracing.md)
+  - [自定义 tracing 的输出格式](logs/tracing-logger.md)
+  - [监控](logs/observe/intro.md)
+    - [可观测性](logs/observe/about-observe.md)
+    - [分布式追踪](logs/observe/trace.md)
 - [Rust 最佳实践](practice/intro.md)
  - [日常开发三方库精选](practice/third-party-libs.md)
  - [命名规范](practice/naming.md)
  - [面试经验](practice/interview.md)
  - [代码开发实践 todo](practice/best-pratice.md)
-  
 - [手把手带你实现链表](too-many-lists/intro.md)
-    - [我们到底需不需要链表](too-many-lists/do-we-need-it.md)
-    - [不太优秀的单向链表：栈](too-many-lists/bad-stack/intro.md)
-      - [数据布局](too-many-lists/bad-stack/layout.md)
-      - [基本操作](too-many-lists/bad-stack/basic-operations.md)
-      - [最后实现](too-many-lists/bad-stack/final-code.md)
-    - [还可以的单向链表](too-many-lists/ok-stack/intro.md)
-      - [优化类型定义](too-many-lists/ok-stack/type-optimizing.md)
-      - [定义 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)
-    - [不咋样的双端队列](too-many-lists/deque/intro.md)
-      - [数据布局和基本操作](too-many-lists/deque/layout.md)
-      - [Peek](too-many-lists/deque/peek.md)
-      - [基本操作的对称镜像](too-many-lists/deque/symmetric.md)
-      - [迭代器](too-many-lists/deque/iterator.md)
-      - [最终代码](too-many-lists/deque/final-code.md)
-    - [不错的unsafe队列](too-many-lists/unsafe-queue/intro.md)
-      - [数据布局](too-many-lists/unsafe-queue/layout.md)
-      - [基本操作](too-many-lists/unsafe-queue/basics.md)
-      - [Miri](too-many-lists/unsafe-queue/miri.md)
-      - [栈借用](too-many-lists/unsafe-queue/stacked-borrow.md)
-      - [测试栈借用](too-many-lists/unsafe-queue/testing-stacked-borrow.md)
-      - [数据布局2](too-many-lists/unsafe-queue/layout2.md)
-      - [额外的操作](too-many-lists/unsafe-queue/extra-junk.md)
-      - [最终代码](too-many-lists/unsafe-queue/final-code.md)
-    - [使用高级技巧实现链表](too-many-lists/advanced-lists/intro.md)
-      - [生产级可用的双向链表](too-many-lists/advanced-lists/unsafe-deque.md)
-      - [双单向链表](too-many-lists/advanced-lists/double-singly.md)
-      - [栈上的链表](too-many-lists/advanced-lists/stack-allocated.md)
-
+  - [我们到底需不需要链表](too-many-lists/do-we-need-it.md)
+  - [不太优秀的单向链表：栈](too-many-lists/bad-stack/intro.md)
+    - [数据布局](too-many-lists/bad-stack/layout.md)
+    - [基本操作](too-many-lists/bad-stack/basic-operations.md)
+    - [最后实现](too-many-lists/bad-stack/final-code.md)
+  - [还可以的单向链表](too-many-lists/ok-stack/intro.md)
+    - [优化类型定义](too-many-lists/ok-stack/type-optimizing.md)
+    - [定义 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)
+  - [不咋样的双端队列](too-many-lists/deque/intro.md)
+    - [数据布局和基本操作](too-many-lists/deque/layout.md)
+    - [Peek](too-many-lists/deque/peek.md)
+    - [基本操作的对称镜像](too-many-lists/deque/symmetric.md)
+    - [迭代器](too-many-lists/deque/iterator.md)
+    - [最终代码](too-many-lists/deque/final-code.md)
+  - [不错的 unsafe 队列](too-many-lists/unsafe-queue/intro.md)
+    - [数据布局](too-many-lists/unsafe-queue/layout.md)
+    - [基本操作](too-many-lists/unsafe-queue/basics.md)
+    - [Miri](too-many-lists/unsafe-queue/miri.md)
+    - [栈借用](too-many-lists/unsafe-queue/stacked-borrow.md)
+    - [测试栈借用](too-many-lists/unsafe-queue/testing-stacked-borrow.md)
+    - [数据布局 2](too-many-lists/unsafe-queue/layout2.md)
+    - [额外的操作](too-many-lists/unsafe-queue/extra-junk.md)
+    - [最终代码](too-many-lists/unsafe-queue/final-code.md)
+  - [使用高级技巧实现链表](too-many-lists/advanced-lists/intro.md)
+    - [生产级可用的双向链表](too-many-lists/advanced-lists/unsafe-deque.md)
+    - [双单向链表](too-many-lists/advanced-lists/double-singly.md)
+    - [栈上的链表](too-many-lists/advanced-lists/stack-allocated.md)

 # 高级专题
+
 ---

 - [征服编译错误](compiler/intro.md)
+
  - [对抗编译检查](compiler/fight-with-compiler/intro.md)
    - [生命周期](compiler/fight-with-compiler/lifetime/intro.md)
      - [生命周期过大-01](compiler/fight-with-compiler/lifetime/too-long1.md)
@ -254,6 +265,7 @@
    - [警惕 UTF-8 引发的性能隐患](compiler/pitfalls/utf8-performance.md)

 - [Rust 性能优化 todo](profiling/intro.md)
+
  - [深入内存 todo](profiling/memory/intro.md)
    - [指针和引用 todo](profiling/memory/pointer-ref.md)
    - [未初始化内存 todo](profiling/memory/uninit.md)
@ -280,13 +292,12 @@
      - [Option 枚举 todo](profiling/compiler/optimization/option.md)

 - [标准库解析 todo](std/intro.md)
+
  - [标准库使用最佳时间 todo](std/search.md)
  - [Vector 常用方法 todo](std/vector.md)
  - [HashMap todo](std/hashmap.md)
  - [Iterator 常用方法 todo](std/iterator.md)

-
-
  <!-- - [配置文件解析 todo](cookbook/config.md)
  - [编解码 todo](cookbook/encoding/intro.md)
    - [JSON](cookbook/encoding/json.md)
@ -314,8 +325,8 @@
 - [Rust前端开发入门]()
 - [Rust和WASM]() -->

-
 # 附录
+
 ---

 - [Appendix]()
@ -329,3 +340,5 @@
    - [1.58](appendix/rust-versions/1.58.md)
    - [1.59](appendix/rust-versions/1.59.md)
    - [1.60](appendix/rust-versions/1.60.md)
+    - [1.61](appendix/rust-versions/1.61.md)
+
--- a/src/appendix/rust-versions/1.61.md
+++ b/src/appendix/rust-versions/1.61.md
@ -0,0 +1,70 @@
+# Rust 新版解读 | 1.61 | 重点: 自定义 main 函数 ExitCode、const fn 增强、为锁定的 stdio 提供静态句柄
+
+> 原文链接: https://blog.rust-lang.org/2022/05/19/Rust-1.61.0.html
+> 翻译 by ：[AllanDowney](https://github.com/AllanDowney)
+
+通过 [rustup](https://www.rust-lang.org/tools/install) 安装的同学可以使用以下命令升级到 1.61 版本:
+
+```shell
+$ rustup update stable
+```
+
+## 支持自定义 main 函数 ExitCode
+
+一开始， Rust `main` 函数只能返回单元类型 `()`（隐式或显式），总是指示成功的退出状态，如果您要你想要其它的，必须调用 `process::exit(code)`。从 Rust 1.26 开始， `main` 允许返回一个 `Result` ，其中 `Ok` 转换为 `C EXIT_SUCCESS`，`Err` 转换为 `EXIT_FAILURE`（也调试打印错误）。在底层，这些返回类型统一使用不稳定的 `Termination` 特征。
+
+在此版本中，最终稳定了 `Termination` 特征，以及一个更通用的 `ExitCode` 类型，它封装了特定于平台的返回类型。它具有 `SUCCESS` 和 `FAILURE` 常量，并为更多任意值实现 `From<u8>`。也可以为您自己的类型实现 `Termination` 特征，允许您在转换为 `ExitCode` 之前定制任何类型的报告。
+
+例如，下面是一种类型安全的方式来编写 `git bisect` 运行脚本的退出代码：
+
+```rust
+use std::process::{ExitCode, Termination};
+
+#[repr(u8)]
+pub enum GitBisectResult {
+    Good = 0,
+    Bad = 1,
+    Skip = 125,
+    Abort = 255,
+}
+
+impl Termination for GitBisectResult {
+    fn report(self) -> ExitCode {
+        // Maybe print a message here
+        ExitCode::from(self as u8)
+    }
+}
+
+fn main() -> GitBisectResult {
+    std::panic::catch_unwind(|| {
+        todo!("test the commit")
+    }).unwrap_or(GitBisectResult::Abort)
+}
+```
+
+## const fn 增强
+
+这个版本稳定了几个增量特性，以支持 const 函数的更多功能：
+
+- `fn` 指针的基本处理：现在可以在 `const fn` 中创建、传递和强制转换函数指针。例如，在为解释器构建编译时函数表时，这可能很有用。但是，仍然不允许调用 `fn` 指针。
+- 特征约束：现在可以将特征约束写在 `const fn` 的泛型参数上，如 `T: Copy`，以前只允许 `Sized`。
+- `dyn Trait` 类型：类似地，`const fn` 现在可以处理特征对象 `dyn Trait`。
+- `impl Trait` 类型：`const fn` 的参数和返回值现在可以是不透明的 `impl Trait` 类型。
+
+注意，特征特性还不支持在 `const fn` 中调用这些特征的方法。
+
+## 为锁定的 stdio 提供静态句柄
+
+三种标准 I/O 流 —— `Stdin` 、`Stdout` 和 `Stderr` —— 都有一个 `锁(&self)`，允许对同步读写进行更多控制。但是，它们返回的锁守卫具有从 `&self` 借来的生命周期，因此它们被限制在原始句柄的范围内。这被认为是一个不必要的限制，因为底层锁实际上是在静态存储中，所以现在守卫返回一个 `'static` 生命期，与句柄断开连接。
+
+例如，一个常见的错误来自于试图获取一个句柄并将其锁定在一个语句中:
+
+```rust
+// error[E0716]: temporary value dropped while borrowed
+let out = std::io::stdout().lock();
+//        ^^^^^^^^^^^^^^^^^       - temporary value is freed at the end of this statement
+//        |
+//        creates a temporary which is freed while still in use
+```
+
+现在锁守卫是 `'static`，而不是借用那个临时的，所以这个可以正常工作！
--- a/src/index-list.md
+++ b/src/index-list.md
@ -10,14 +10,20 @@

 <a id="head"></a>

-|       NN        |    NN    |   NN    |   NN    |   NN    |   NN    |   NN    |   NN    |   NN    |   NN    |   NN    |
-| :-------------: | :------: | :-----: | :-----: | :-----: | :-----: | :-----: | :-----: | :-----: | :-----: | :-----: |
-|    [#](#sym)    | [A](#a)  | [B](#b) | [C](#c) | [D](#d) | [E](#e) | [F](#f) | [G](#g) | [H](#h) | [I](#i) | [J](#j) |
-|     [K](#k)     | [L](#l)  | [M](#m) | [N](#n) | [O](#o) | [P](#p) | [Q](#q) | [R](#r) | [S](#s) | [T](#t) | [U](#u) |
-|     [V](#v)     | [W](#w)  | [X](#x) | [Y](#y) | [Z](#z) |
-| [Cargo](#cargo) | [Naming] |
+|    NN     |   NN    |   NN    |   NN    |   NN    |   NN    |   NN    |   NN    |   NN    |
+| :-------: | :-----: | :-----: | :-----: | :-----: | :-----: | :-----: | :-----: | :-----: |
+| [#](#sym) | [A](#a) | [B](#b) | [C](#c) | [D](#d) | [E](#e) | [F](#f) | [G](#g) | [H](#h) |
+|  [I](#i)  | [J](#j) | [K](#k) | [L](#l) | [M](#m) | [N](#n) | [O](#o) | [P](#p) | [Q](#q) |
+|  [R](#r)  | [S](#s) | [T](#t) | [U](#u) | [V](#v) | [W](#w) | [X](#x) | [Y](#y) | [Z](#z) |
+
+</br>
+
+|       NN        |    NN    |     NN     |
+| :-------------: | :------: | :--------: |
+| [Cargo](#cargo) | [Naming] | [Keywords] |

 [naming]: https://course.rs/practice/naming.html
+[keywords]: https://course.rs/appendix/keywords.html

 [bottom](#bottom)

@ -58,24 +64,27 @@
 | ------------- | -------- | ---------------------------------------------------------------------------------------------------------------------- |
 | [array 数组]  | 数组     | 长度固定<br>元素必须有相同的类型<br>依次线性排列<br>可以通过索引访问其中的元素<br>`let a: [i32; 5] = [1, 2, 3, 4, 5];` |
 | [array slice] | 数组切片 | `let slice: &[i32] = &a[1..3];`                                                                                        |
+| [as 转换]     | 类型转换 | `(x as T)`                                                                                                             |
 |               | KWA      |                                                                                                                        |

 [array 数组]: https://course.rs/basic/compound-type/array.html
 [array slice]: https://course.rs/basic/compound-type/array.html#数组切片
+[as转换]: https://course.rs/basic/converse.html#as转换

 [back](#head)

 ## B

-| 名称         | 关键字    | 简介                                                                           |
-| ------------ | --------- | ------------------------------------------------------------------------------ |
-| [变量遮蔽]   | shadowing | 允许声明相同的变量名，后者会遮蔽掉前者                                         |
-| [变量覆盖]   | 模式匹配  | 无论是是 `match` 还是 `if let`，他们都可以在模式匹配时覆盖掉老的值，绑定新的值 |
-| [变量作用域] | 所有权    | 作用域是一个变量在程序中有效的范围                                             |
-| [表达式]     |           | 进行求值，结尾无 `;`，有返回值                                                 |
-| [bool 布尔]  | 布尔类型  | `true` `false`，占用 1 字节                                                    |
-| [break]      | 循环控制  | 直接跳出当前整个循环                                                           |
-|              | KWB       |                                                                                |
+| 名称               | 关键字       | 简介                                                                           |
+| ------------------ | ------------ | ------------------------------------------------------------------------------ |
+| [变量遮蔽]         | shadowing    | 允许声明相同的变量名，后者会遮蔽掉前者                                         |
+| [变量覆盖]         | 模式匹配     | 无论是是 `match` 还是 `if let`，他们都可以在模式匹配时覆盖掉老的值，绑定新的值 |
+| [变量作用域]       | 所有权       | 作用域是一个变量在程序中有效的范围                                             |
+| [表达式]           |              | 进行求值，结尾无 `;`，有返回值                                                 |
+| [bool 布尔]        | 布尔类型     | `true` `false`，占用 1 字节                                                    |
+| [break]            | 循环控制     | 直接跳出当前整个循环                                                           |
+| [backtrace 栈展开] | 不可恢复错误 | `RUST_BACKTRACE=1 cargo run`                                                   |
+|                    | KWB          |                                                                                |

 [变量遮蔽]: https://course.rs/basic/variable.html#变量遮蔽shadowing
 [变量覆盖]: https://course.rs/basic/match-pattern/match-if-let.html#变量覆盖
@ -83,6 +92,7 @@
 [bool 布尔]: https://course.rs/basic/base-type/char-bool.html#布尔bool
 [表达式]: https://course.rs/basic/base-type/statement-expression.html#表达式
 [break]: https://course.rs/basic/flow-control.html#break
+[backtrace 栈展开]: https://course.rs/basic/result-error/panic.html#backtrace-栈展开

 [back](#head)

@ -111,13 +121,15 @@

 ## D

-| 名称     | 关键字   | 简介                                                                                |
-| -------- | -------- | ----------------------------------------------------------------------------------- |
-| [derive] | 派生特征 | `#[derive(Trait)]`，被标记的对象自动实现对应的默认特征代码<br>详见：[附录-派生特征] |
-|          | KWD      |                                                                                     |
+| 名称       | 关键字   | 简介                                                                                                             |
+| ---------- | -------- | ---------------------------------------------------------------------------------------------------------------- |
+| [derive]   | 派生特征 | `#[derive(Trait)]`，被标记的对象自动实现对应的默认特征代码<br>详见：[附录-派生特征]                              |
+| [点操作符] | 类型转换 | 方法调用的点操作符，在调用时，会发生很多魔法般的类型转换，例如：自动引用、自动解引用，强制类型转换直到类型能匹配 |
+|            | KWD      |                                                                                                                  |

 [derive]: https://course.rs/basic/trait/trait.html#通过-derive-派生特征
 [附录-派生特征]: https://course.rs/appendix/derive.html
+[点操作符]: https://course.rs/basic/converse.html#点操作符

 [back](#head)

@ -284,9 +296,14 @@

 ## P

-| 名称 | 关键字 | 简介 |
-| ---- | ------ | ---- |
-|      | KWP    |      |
+| 名称                  | 关键字       | 简介                                                                 |
+| --------------------- | ------------ | -------------------------------------------------------------------- |
+| [panic! 不可恢复错误] | 不可恢复错误 | 程序会打印出一个错误信息，展开报错点往前的函数调用堆栈，最后退出程序 |
+| [panic 原理剖析]      | 不可恢复错误 |                                                                      |
+|                       | KWP          |                                                                      |
+
+[panic! 不可恢复错误]: https://course.rs/basic/result-error/panic.html#panic-与不可恢复错误
+[panic 原理剖析]: https://course.rs/basic/result-error/panic.html#panic-原理剖析

 [back](#head)

@ -300,12 +317,16 @@

 ## R

-| 名称         | 关键字 | 简介                                                                               |
-| ------------ | ------ | ---------------------------------------------------------------------------------- |
-| [Range 序列] |        | 生成连续的数值<br> 只允许用于数字或字符类型<br> `..` 右半开区间 <br>`..=` 闭合区间 |
-|              | KWR    |                                                                                    |
+| 名称                   | 关键字     | 简介                                                                               |
+| ---------------------- | ---------- | ---------------------------------------------------------------------------------- |
+| [Range 序列]           |            | 生成连续的数值<br> 只允许用于数字或字符类型<br> `..` 右半开区间 <br>`..=` 闭合区间 |
+| [Result 可恢复的错误]  | 可恢复错误 | `enum Result<T, E> { Ok(T), Err(E), }`                                             |
+| [对返回的错误进行处理] | 可恢复错误 | 对返回的错误进行处理                                                               |
+|                        | KWR        |                                                                                    |

 [range 序列]: https://course.rs/basic/base-type/numbers.html#序列range
+[result 可恢复的错误]: https://course.rs/basic/result-error/result.html#可恢复的错误-result
+[对返回的错误进行处理]: https://course.rs/basic/result-error/result.html#对返回的错误进行处理

 [back](#head)

@ -347,6 +368,7 @@
 | [Trait Object]                             | 特征对象   | 特征对象指向实现了 `Trait` 特征的类型的实例，可以在运行时通过特征对象找到具体调用的类型方法                                                                                                 |
 | `type` 1. [关联类型] 2. [默认泛型类型参数] |            | 1. `type Item;`<br>`Self` 用来指代当前调用者的具体类型，那么 `Self::em` 就用来指代该类型实现中定义的 `Item` 类型<br>2. `type Output = Struct;`<br>指定一个默认值，返回一个关联类型 `Output` |
 | [特征定义中的特征约束]                     | 特征       | 用来说明一个特征需要实现另一个特征                                                                                                                                                          |
+| [TryInto 转换]                             | 类型转换   | 尝试进行一次转换，并返回一个 `Result`，可以对其进行相应的错误处理                                                                                                                           |
 |                                            | KWT        |                                                                                                                                                                                             |

 [tuple 元组]: https://course.rs/basic/compound-type/tuple.html#元组
@ -357,17 +379,20 @@
 [关联类型]: https://course.rs/basic/trait/advance-trait.html#关联类型
 [默认泛型类型参数]: https://course.rs/basic/trait/advance-trait.html#默认泛型类型参数
 [特征定义中的特征约束]: https://course.rs/basic/trait/advance-trait.html#特征定义中的特征约束
+[tryinto 转换]: https://course.rs/basic/converse.html#tryinto-转换

 [back](#head)

 ## U

-| 名称               | 关键字     | 简介                                        |
-| ------------------ | ---------- | ------------------------------------------- |
-| [Unit-like Struct] | 单元结构体 | 没有任何字段和属性<br>`struct AlwaysEqual;` |
-|                    | KWU        |                                             |
+| 名称               | 关键字     | 简介                                                              |
+| ------------------ | ---------- | ----------------------------------------------------------------- |
+| [Unit-like Struct] | 单元结构体 | 没有任何字段和属性<br>`struct AlwaysEqual;`                       |
+| [unwrap & expect]  | 可恢复错误 | 如果返回成功，就将 `Ok(T)` 中的值取出来，如果失败，就直接 `panic` |
+|                    | KWU        |                                                                   |

 [unit-like struct]: https://course.rs/basic/compound-type/struct.html#单元结构体unit-like-struct
+[unwrap & expect]: https://course.rs/basic/result-error/result.html#失败就-panic-unwrap-和-expect

 [back](#head)

--- a/src/rust-weekly.md
+++ b/src/rust-weekly.md
@ -5,80 +5,56 @@ Rust语言周刊精选全世界过去一周的优秀文章、新闻、开源项

 > RustCn：https://hirust.cn, 公众号: Rust语言中文网

-# 「Rust 语言周刊」 第 13 期 · 2022-05-22
-
-<img src="https://pic1.zhimg.com/80/v2-cd8fc37f15c5547a0853a92a9e06c528_1440w.webp">
-<h5 align="center">题图: 将 Ruby 的编译器移植到 Rust 上</h5>
-
-#### 官方新闻
-
-1、[Rust 发布 1.61 版本](https://blog.rust-lang.org/2022/05/19/Rust-1.61.0.html)
-
-在历次版本更迭中，Rust 的 `fn main` 函数经历了从返回单元类型 `()`，到返回 `Result`，这两个实际上都是通过 `Termination` 特征来返回一个状态码(Exit Status)。
-
-但之前该特征并没有稳定，我们无法自定义想要的返回状态码，而新版本中中，该特征最终稳定下来。
-
-除此之外还有对常量函数 (const fn) 的进一步支持，意味着我们可以将更多的任务放在编译期去执行了。
-
-#### 开源项目
-
-1、[BlindAI: 一个基于 Rust 的开源 AI 项目](https://blog.mithrilsecurity.io/introducing-blindai/)
-
-谁说 Rust 在机器学习/人工智能方面是纯纯的菜鸟？这不，我们拥有了一个纯 Rust 编写的、现代化的...AI 模型部署工具，它可以把我们创建的 AI 模型方便地部署在远程服务器上，同时对终端用户提供安全的访问接口。
+# 「Rust 语言周刊」 第 14 期 · 2022-05-29
+Rust语言周刊精选全世界过去一周的优秀文章、新闻、开源项目和语言动态。

-<img src="https://pic2.zhimg.com/80/v2-dafe81318a7f3e25d73b704251fad4c6_1440w.gif" />
+本周刊由 RustCn 社区倾情打造，其中， `[Zh]` 标识的中文资料由 Rust 翻译计划提供，并且原始的 Markdown 文档已[全部开源](https://github.com/rustlang-cn/rustt)，欢迎大家阅读和订阅。

-2、[Fyrox 发布 0.25 版本](https://fyrox.rs/blog/post/feature-highlights-0-25/)
+> RustCn：https://hirust.cn, 公众号: Rust语言中文网

-对于 Fyrox 大家可能不熟悉，但是提到 rg3d，很多人可能就恍然大悟了。是的， fyrox 它的新名字( 我觉得新名字比老的要好，未来更好推广，但是还是建议大家在项目初期想一个好的名字，不然后面改名的隐形成本实在太高了！)
+<img src="https://pic1.zhimg.com/80/v2-cd8fc37f15c5547a0853a92a9e06c528_1440w.webp">
+<h5 align="center">题图: 将 Ruby 的编译器移植到 Rust 上</h5>

-在新版本中，主要是引入了静态插件和脚本的支持，其中一个用途就是用来扩展游戏引擎，例如现在的 fyrox 支持在游戏编辑器中运行游戏了，就像很多知名的游戏引擎一样！
+#### Rust 项目

-<img src="https://pic1.zhimg.com/80/v2-7ba91c93e0c8ebe1e2a7928434173414_1440w.jpeg" />
+1、[IntelliJ 的 Rust 插件发布新版本](https://blog.jetbrains.com/rust/2022/05/19/what-s-new-in-intellij-rust-for-2022-1/)

+Vscode 的 Rust 插件 `rust-analyzer` 已经相当牛了，但是跟 IntelliJ 依然有一定的差距。告诉大家一个小秘密，ra 之前的的核心作者其实也是 IntelliJ Rust 插件的核心开发，当然，现在 ra 在合并到官方组织后，跟以前又有所不同了。

 #### 精选文章

-1、[我们是怎么将 Ruby 编译器移植到 Rust 的](https://shopify.engineering/porting-yjit-ruby-compiler-to-rust)
-
-在 [4 月份时](https://baijiahao.baidu.com/s?id=1730684175033094920&wfr=spider&for=pc)，一个爆炸性的新闻出现：Ruby 的 YJIT 编译器使用 Rust 完成了移植，并等待合并到上游代码仓库中，但当时并没有给出太多的细节。
-
-一个月后的这篇文章中，开发者团队终于解开了神秘的面纱，深入谈了下在移植过程中遇到问题以及收获的经验，值得一读。
-
-2、[Rust和供应链](https://blog.logrocket.com/comparing-rust-supply-chain-safety-tools/)
-
-嗒哒，你可能被题目所欺骗了，以为本文是写 Rust 和物流供应链的，实际上，这是一篇关于 Rust 依赖链的文章，作者貌似对于外部的一切都充满了不信任感，因此希望能发现 Rust 项目中到底使用了哪些库，以及相关的详细信息。
+1、[为了开发一个操作系统，我学习了 Rust 并写下 10 万行代码](https://www.bunniestudios.com/blog/?p=6375)

-如果大家读了后，觉得意犹未尽，这里也有一篇[相似的文章](https://insanitybit.github.io/2022/05/10/supply-chain-thoughts)。
+对于作者所在的公司来说，他们希望能清晰地掌控 OS 的每一个细节，虽说 linux 是开源的，但是它实在太大了，而其他的开源系统或多或少页无法满足他们的需求，因此需要重新手撸一个 OS。那么，在这个时间点，对于这种需求，除了 Rust 之外，还有更好的选择吗？显然没有。

-3、[语言特性真的越多越好吗?](https://www.thecodedmessage.com/posts/2022-05-11-programming-multiparadigm/)
+2、[从零构建一个云数据库：我们为何从 C++ 迁移到 Rust](https://singularity-data.com/blog/building-a-cloud-database-from-scratch-why-we-moved-from-cpp-to-rust/)

-C++ 程序员经常引以为傲的一点就是 C++ 什么都能做，而且还是多编程范式的。如果你对此套路不熟悉，很容易就被其吸引，然后走上一条不归路。
+就我个人而言，真的很羡慕国外的技术人生存环境，你能想象，国内创业公司在开发 7 个月后删除了所有的 C++ 代码，然后从零开始，使用 Rust 从头开始吗？作者所在的公司就是这样一(yi)股(duo)清(qi)流(pa)。

-看了本文后，至少这些套路你将了若指掌，以后互喷起来，不要太愉快 ：P
+3、[修复 Rust 中的内存泄漏问题](https://onesignal.com/blog/solving-memory-leaks-in-rust/)

-4、[使用 Rust 扩展 SQLite](https://ricardoanderegg.com/posts/extending-sqlite-with-rust/)
+OneSignal 是一个消息服务公司，在之前将其中的一些核心服务[迁移到了 Rust 上](https://onesignal.com/blog/rust-at-onesignal/)，在此过程中，他们遇到并解决了不少问题，其中一个就是内存泄漏。

-SQLite 支持多种扩展机制，本文将通过扩展的方式，为 SQLite 实现 zstd 压缩。
+这篇文章干货多多，非常值得深入阅读！

+4、[Rust 中的崩溃处理](https://jake-shadle.github.io/crash-reporting/)

-5、[深入 Rust 异步编程](https://conradludgate.com/posts/async)
+不知道大家学过 Erlang 没，这门语言不仅是现代化并发编程的引路者，还是崩溃哲学的提倡者：错误不应该被隐藏，而是直接抛出来，任其崩溃，若有需要，自动重启任务协程即可(通过 gen_supervisor 统一管理)。

-友情提示，阅读本文，首先你需要坚实的基础？其实不是，你需要一杯咖啡、一个躺椅和一盘小点心，因为它真的挺长。。
+当然，这种特立独行的方式并不适合于所有的语言和开发者，因此 Rust 中并没有内置这套崩溃自动处理系统，而是需要我们根据自己的需求来手动处理，这篇文章就介绍了一些不错的崩溃处理方式。

-6、[Default 和 From](https://elijahcaine.me/rust-default-from/)
+5、[从 BonsaiDb 的性能问题引发的文件同步性能探究](https://bonsaidb.io/blog/durable-writes/)

-从 Python 到 Rust，作者发现代码变得冗长了不少，他的手已然累了。因此，本文将从工程性的角度出发，谈谈 `Default` 和 `From` 在实战中能发挥出什么威力。
+数据库是非常复杂的领域，作者本来想要同时搞定中上层数据库服务和底层数据存储服务，但是在遇到了一系列问题后，现在不禁怀疑，自己实现底层数据存储服务是否是一个正确的抉择。

-7、[游戏开发中的音频为何这么难](https://tesselode.github.io/articles/audio-libraries-considered-challenging/)
+6、[优化 Rust 二进制文件的大小](https://kerkour.com/optimize-rust-binary-size)

-游戏由于 fps 的限制，导致了音视频的开发难度相对其他领域来说会更高一些，作者在编写 [kira](https://github.com/tesselode/kira/) 的过程中，深刻领悟了这一点。
+这篇文章很短，只介绍了优化大小的一些途径( 其实不是很全 )，并没有对此进行深入展开，我个人其实并不想把文章列到周刊中，但是鉴于本期的内容素材并不多，只能向现实屈服了 :(

-8、[系列] [链接 Rust 依赖包 1](https://blog.pnkfx.org/blog/2022/05/12/linking-rust-crates/)
+7、[使用 Github Actions 来测试和构建你的 Rust 应用](https://kerkour.com/rust-github-actions-ci-cd)

-说到依赖包，应该没人不知道 `bin` 和 `lib` 类型，前者可以编译成可运行的二进制文件，后者则是常用的依赖库。但是以下这些呢？`bin, lib, dylib, staticlib, cdylib, rlib, and proc-macro`，能够一一说出的同学，请举个爪 =，= 
+这篇文章的推荐程度同上，如果大家想要全面了解 Github Actions，可以看看 Rust 语言圣经中的[这篇章节](https://course.rs/test/ci.html)。

-而文章要做的就是通过系列文章的方式带大家通过示例的方式熟悉这些库类型，本文是第一篇。



@ -89,6 +65,7 @@ SQLite 支持多种扩展机制，本文将通过扩展的方式，为 SQLite

 目前所有的周刊都按照 `年/月/日期` 的方式归纳在 [docs](./docs) 目录下，大家可以按需查看。

+- [第 13 期](./docs/2022/5月/22.md)
 - [第 12 期](./docs/2022/5月/16.md)
 - [第 11 期](./docs/2022/5月/07.md)
 - [第 10 期](./docs/2022/4月/29.md)