feat: 🎸 更新 HRTBs 等内容

Author: uxiew

docs/notes/[相关资料].md

@@ -42,6 +42,9 @@
 
 ## 相关资源🔗
 
+* 从零开始用 Rust 语言写一个基于 RISC-V 架构的 类 Unix 内核
+  - 链接：https://rcore-os.cn/rCore-Tutorial-Book-v3/index.html
+
 * Teach-rs 面向计算机科学专业学生的 Rust 编程语言
   - 链接：https://github.com/tweedegolf/teach-rs
 
@@ -156,6 +159,9 @@
 
 ## 大牛博客
 
+- pretzelhammer's Rust blog 🦀
+  - 链接：https://github.com/pretzelhammer/rust-blog
+
 - Manishearth-blog
   - 链接：https://manishearth.github.io/blog/categories/rust/
 

docs/notes/awesome rust.md

@@ -1,10 +1,56 @@
 Rust 生态系统由许多库和工具组成，可用于构建各种应用程序。其中一些库包括：
 
-## Rust 前端框架
+## Rust frontend frameworks
+
+- [Leptos](https://github.com/leptos-rs/leptos)
+
+- [Yew](https://github.com/yewstack/yew)
+
+- [Sycamore](https://github.com/sycamore-rs/sycamore)
+
+- [Perseus](https://github.com/framesurge/perseus)
+
+- [Sauron](https://github.com/ivanceras/sauron)
+
+- [MoonZoon](https://github.com/MoonZoon/MoonZoon)
+
+- [Percy](https://github.com/chinedufn/percy)
+
+
+## Rust Backend frameworks
+
+- [Axum](https://github.com/tokio-rs/axum)
+
+- [salvo](https://github.com/salvo-rs/salvo/)
+
+- [Axum](https://github.com/tokio-rs/axum)
+
+- [Rocket](https://rocket.rs/)
+
+- [Tide](https://github.com/http-rs/tide)
+
+- [Cot](https://github.com/CotApp/cot)
+
+- [Gotham](https://gotham.rs/)
 
 - [seed](https://github.com/seed-rs/seed)
 
-- [Actix](https://actix.rs/)
+- [Actix Web](https://actix.rs/)
+
+- [Warp](https://github.com/seanmonstar/warp)
+
+- [Loco](https://loco.rs/)
+
+- [Thruster](https://github.com/thruster-rs/Thruster)
+
+- [Dropshot](https://github.com/oxidecomputer/dropshot)
+
+- [Rouille](https://github.com/tomaka/rouille)
+
+## OpenAPI Documentation
+
+- [utoipa](https://github.com/juhaku/utoipa)
+  Simple, Fast, Code first and Compile time generated OpenAPI documentation for Rust
 
 ## Operating Systems
 
@@ -28,6 +74,10 @@ Rust 生态系统由许多库和工具组成，可用于构建各种应用程序
 
 ## GUI
 
+- [vizia](https://github.com/vizia/vizia)
+  Vizia is a crate for building desktop GUI applications.
+  https://book.vizia.dev/
+
 - [gpui](https://www.gpui.rs)
   A fast, productive UI framework for Rust from the creators of Zed.
   https://github.com/topics/gpui
@@ -51,8 +101,8 @@ Rust 生态系统由许多库和工具组成，可用于构建各种应用程序
 
 - [freya](https://github.com/marc2332/freya)
 
-- [Vizia](https://github.com/vizia/vizia/)
-  A declarative GUI library written in Rust
+- [egui](https://github.com/emilk/egui)
+  An easy-to-use GUI library for Rust
 
 ## proxy
 

docs/notes/详解内存布局.md

@@ -173,6 +173,63 @@ fn example() {
 }
 ```
 
+## 数组与字符串内存布局
+
+```rust
+fn main() {
+    println!("\n========== 数组内存布局演示 ==========");
+    let arr = [1, 2, 3, 4, 5];      // 栈上
+
+    println!("数组内存地址: {:p}", &arr);
+    println!("第一个元素地址: {:p}", &arr[0]);
+    println!("第二个元素地址: {:p}", &arr[1]);
+
+    println!("\n========== 字符串内存布局演示 ==========");
+    let str_literal = "Hello";                     // 存储在程序二进制中
+    let string_heap = String::from("Hello");       // 存储在堆上
+
+    println!("字符串字面量地址: {:p}", str_literal);
+    println!("String 对象地址: {:p}", &string_heap);
+    println!("String 内容地址: {:p}", string_heap.as_ptr());
+
+    // 展示 String 的容量概念
+    let mut dynamic_string = String::with_capacity(10);
+    println!("初始容量: {}", dynamic_string.capacity());
+
+    dynamic_string.push_str("Hello");
+    println!("添加内容后 - 长度: {}, 容量: {}",
+    dynamic_string.len(), dynamic_string.capacity());
+
+    dynamic_string.push_str(" Rust Programming");
+    println!("再次添加后 - 长度: {}, 容量: {}",
+    dynamic_string.len(), dynamic_string.capacity());
+}
+```
+
+```
+数组内存布局:
+┌─────────────────────────────────────────────────────────┐
+│  栈内存 (Stack)                                          │
+│  ┌───┬───┬───┬───┬───┐                                   │
+│  │ 1 │ 2 │ 3 │ 4 │ 5 │  [i32; 5]                       │
+│  └───┴───┴───┴───┴───┘                                   │
+│  连续内存地址                                              │
+└─────────────────────────────────────────────────────────┘
+
+字符串内存布局:
+┌─────────────────────────────────────────────────────────┐
+│  栈内存 (Stack)        │        堆内存 (Heap)            │
+│  ┌─────────────────┐   │   ┌─────────────────────────────┐│
+│  │ String 对象      │   │   │ 实际字符串数据              ││
+│  │ ┌─────────────┐ │   │   │ ┌─┬─┬─┬─┬─┬─┐            ││
+│  │ │ ptr        ─┼─┼───┼──▶│ │H│e│l│l│o│\0│            ││
+│  │ │ len: 5     │ │   │   │ └─┴─┴─┴─┴─┴─┘            ││
+│  │ │ capacity: 8│ │   │   │                             ││
+│  │ └─────────────┘ │   │   └─────────────────────────────┘│
+│  └─────────────────┘   │                                 │
+└─────────────────────────────────────────────────────────┘
+```
+
 ## 元组（Tuple）内存布局
 
 让我们通过一个具体例子来理解元组的内存布局：

docs/第 22 章 闭包/22.5 闭包与生命周期.md

@@ -2,8 +2,6 @@
 
 当使用闭包做参数或返回值的时候，生命周期会变得更加复杂。假设有下面这段代码：
 
----
-
 ```rust
 fn calc_by<'a, F>(var: &'a i32, f: F) -> i32
     where F: Fn(&'a i32) -> i32
@@ -18,25 +16,17 @@ fn main() {
 }
 ```
 
----
-
-这段代码可以编译通过。但是，假如我们把 calc\_by 的函数体稍微改一下，变成下面这样：
-
----
+这段代码可以编译通过。但是，假如我们把 `calc_by` 的函数体稍微改一下，变成下面这样：
 
 ```rust
 let local = *var;
 f(&local)
 ```
 
----
-
 就不能编译通过了。
 
 但是，如果我们把所有的生命周期标记去掉，变成这样：
 
----
-
 ```rust
 fn calc_by<F>(var: &i32, f: F) -> i32
     where F: Fn(&i32) -> i32
@@ -52,29 +42,21 @@ fn main() {
 }
 ```
 
----
+这时所有的借用生命周期由编译器自动补全，又可以编译通过了。这说明，我们之前对这个 `calc_by` 函数手写的生命周期标记有问题。那我们手动来补全这些标记，应该怎么做呢？
 
-它就又可以编译通过了。这说明，我们前面对这个 calc\_by 函数手写的生命周期标记有问题。
-
-对于上面这个例子，所有的借用生命周期都是由编译器自动补全的，假如我们手动来补全这些标记，应该怎么做呢？
-
-在这里我们只能使用“高阶生命周期”的表示方法：
-
----
+在这里我们只能使用“高阶生命周期约束”，即**高阶特征约束**（Higher-Ranked Trait Bounds）(HRTBs) 的表示方法：
 
 ```rust
 fn calc_by<'a, F>(var: &'a i32, f: F) -> i32
-    where F: for<'f> Fn(&'f i32) -> i32
+    where for<'f> F: Fn(&'f i32) -> i32
 {
     let local = *var;
     f(&local)
 }
 ```
 
----
-
-注意 F 的约束条件，这样写表示的意思是，Fn 的输入参数可作用于任意的生命周期'f，这个生命周期和另外一个参数 var 的生命周期没有半点关系。
+注意 `F` 的约束条件，其中 `for<'f>` 是高阶约束的标志，声明了一个**通用生命周期 `'f`**。这样写表示的意思是，Fn 的输入参数摆脱外部参数生命周期的限制，适配任意合法的生命周期`'f`。这个生命周期和另外一个参数 `var` 的生命周期没有半点关系。
 
-这才是这段代码正确的生命周期标记方式。如果我们不手动标记出来，编译器为我们自动推导的生命周期关系就是这样的高阶生命周期。
+这才是这段代码正确的生命周期标记方式。如果我们不手动标记出来，编译器会巧妙地创建了一些隐式的高阶生命周期参数边界（HRTBs）。
 
-谈到“高阶”这两个字，很多朋友会想到高阶类型（higher kinded types）。这里的高阶生命周期确实跟高阶类型有很多相似之处，Rust 也确实在思考如何引入高阶类型这个问题，但还没有做出最终决定。到目前为止，for<'a>Fn（&'a Arg）->&'a Ret 这样的语法，只能用于生命周期参数，不能用于任意泛型类型。
+谈到“高阶”这两个字，很多朋友会想到高阶类型（Higher-Kinded Types）。这里的高阶生命周期确实跟高阶类型有很多相似之处，Rust 也确实在思考如何引入高阶类型这个问题。到目前为止，`for<'a> Fn(&'a Arg) -> &'a Ret` 这样的语法，只能用于生命周期参数，不能用于任意泛型类型。

docs/第 25 章 协程/25.5 异步.md

@@ -8,7 +8,7 @@ async 和 await 关键字是目前许多语言都采用的主流方案，使用
 
 ## 25.5.1 核心构件 `Future`
 
-Future 是一个 Trait，Future 可以组合，一个 Future 可以由其他的一个或者多个 Future 包装而成。跟我们已经见过的迭代器 Iterator 很像。比如，我们可以实现一个新的 Future，它的结果是多个 Future 按顺序执行得到的。或者，实现一个 Future，它的结果是两个子 Future 中先返回的那个。Future 组合的方式可以非常灵活。
+Future 是一个 Trait，Future 可以组合，一个 Future 可以由其他的一个或者多个 Future 包装而成。跟我们已经见过的迭代器 Iterator 很像。
 
 其简化定义如下：
 

docs/第 25 章 协程/25.6 Coroutine 与 Future.md

@@ -20,8 +20,6 @@
 
 > **关键洞察**：在 `std` 层面，`Future` 和 `Coroutine` 是两个正交（Orthogonal）的概念。`Future` 是**面向生态的协议**，而 `Coroutine` 是**面向编译器的原语**。它们被设计为可以独立存在，这增加了语言的灵活性和模块化程度。
 
----
-
 ### **第二层：`async/await` —— 胶水和魔法的来源（在编译器中）**
 
 现在，我们有了两种积木，但它们如何协同工作来构建出我们想要的城堡（即 `async` 函数）呢？这就是 `async/await` 语法和编译器发挥作用的地方。

docs/第 4 章 函数/4.1 简介.md

@@ -1,37 +1,28 @@
 # 4.1 简介
 
-Rust 的函数使用关键字`fn`开头。函数可以有一系列的输入参数，还有一个返回类型。函数体包含一系列的语句（或者表达式）。函数返回可以使用 return 语句，也可以使用表达式。Rust 编写的可执行程序的入口就是`fn main()`函数。以下是一个函数的示例：
-
----
+Rust 的函数使用关键字`fn`开头。函数可以有一系列的输入参数，还有一个返回类型。函数体包含一系列的语句（或者表达式）。函数返回可以使用 `return` 语句，也可以使用表达式。
+Rust 编写的可执行程序的入口就是 `fn main()` 函数。以下是一个函数的示例：
 
 ```rust
-fn add1(t : (i32,i32)) -> i32 {
+fn add1(t: (i32,i32)) -> i32 {
     t.0 + t.1
 }
 ```
 
----
-
-这个函数有一个输入参数，其类型是 tuple（i32，i32）。它有一个返回值，返回类型是 i32。函数的参数列表与 let 语句一样，也是一个“模式解构”。模式解构的详细解释请参考第 7 章。上述函数也可以写成下面这样：
-
----
+这个函数有一个输入参数，其类型是 tuple `(i32，i32)`。它有一个返回值，返回类型是 `i32`。函数的参数列表与 let 语句一样，也是一个“模式解构”。模式解构的详细解释请参考第 7 章。上述函数也可以写成下面这样：
 
 ```rust
 fn add2((x,y) : (i32,i32)) -> i32 {
     x + y
 }
 ```
 
----
-
 函数体内部是一个表达式，这个表达式的值就是函数的返回值。也可以写`return x + y;`这样的语句作为返回值，效果是一样的。
 
-函数也可以不写返回类型，在这种情况下，编译器会认为返回类型是`unit()`。此处和表达式的规定是一致的。
+函数也可以不写返回类型，在这种情况下，编译器会认为返回类型是 unit 类型 `()`。此处和表达式的规定是一致的。
 
 函数可以当成头等公民（first class value）被复制到一个值中，这个值可以像函数一样被调用。示例如下：
 
----
-
 ```rust
 fn main() {
     let p = (1, 3);
@@ -75,11 +66,7 @@ error[E0308]: mismatched types
               found type `fn((i32, i32)) -> i32 {add2}`
 ```
 
----
-
-虽然`add1`和`add2`有同样的参数类型和同样的返回值类型，但它们是不同类型，所以这里报错了。修复方案是让 func 的类型为通用的 fn 类型即可：
-
----
+虽然 `add1` 和 `add2` 有同样的参数类型和同样的返回值类型，但它们是不同类型，所以这里报错了。修复方案是让 func 的类型为通用的 fn 类型即可：
 
 ```rust
 // 写法一，用 as 类型转换
@@ -88,12 +75,8 @@ let mut func = add1 as fn((i32,i32))->i32;
 let mut func : fn((i32,i32))->i32 = add1;
 ```
 
----
-
 以上两种写法都能修复上面的编译错误。但是，我们不能在参数、返回值类型不同的情况下作类型转换，比如：
 
----
-
 ```rust
 fn add3(x: i32, y: i32) -> i32 {
     x + y
@@ -106,14 +89,10 @@ fn main() {
 }
 ```
 
----
-
-这里再加了一个`add3`函数，它接受两个 i32 参数，这就跟`add1`和`add2`有了本质区别。`add1`和`add2`是一个参数，类型是 tuple 包含两个 i32 成员，而`add3`是两个 i32 参数。三者完全不一样，它们之间是无法进行类型转换的。
+这里再加了一个 `add3` 函数，它接受两个 i32 参数，这就跟 `add1` 和 `add2` 有了本质区别。`add1` 和 `add2` 是一个参数，类型是 tuple 包含两个 i32 成员，而 `add3` 是两个 i32 参数。三者完全不一样，它们之间是无法进行类型转换的。
 
 另外需要提示的就是，Rust 的函数体内也允许定义其他 item，包括静态变量、常量、函数、trait、类型、模块等。比如：
 
----
-
 ```rust
 fn test_inner() {
     static INNER_STATIC: i64 = 42;
@@ -138,6 +117,4 @@ fn test_inner() {
 }
 ```
 
----
-
 当你需要一些 item 仅在此函数内有用的时候，可以把它们直接定义到函数体内，以避免污染外部的命名空间。

docs/第 6 章 数组和字符串/6.2 字符串.md

@@ -17,7 +17,7 @@ fn main () {
 
 创建字符串类型的方法有多种。==`String`类型是在堆上分配的，而`＆str`类型通常是指向现有字符串的指针，该字符串可以是堆栈、堆、已编译对象代码的数据段中的字符串==。
 
-## 6.2.1 &str
+## 6.2.1 `&str`
 
 `str`是 Rust 的内置类型，开发中基本不会使用。通常使用`&str`类型，是对`str`的借用，其实际上指向了一段 UTF-8 编码的字节数组的指针，因此可以看作是`[u8]`类型的切片形式`&[u8]`，是一种固定大小的字符串类型。
 
@@ -115,9 +115,9 @@ fn main() {
 }
 ```
 
-## 6.2.2 String
-String 类型是 Rust 标准库提供的一种可增长的字符串类型，
-其实际上是一个包含了指向堆上分配的 UTF-8 编码字节数组的指针、字节数组的长度和容量等信息的结构体，并且提供了很多字符串相关的函数。
+## 6.2.2 `String`
+
+`String` 类型是 Rust 标准库提供的一种可增长的字符串类型，其实际上是一个包含了指向堆上分配的 UTF-8 编码字节数组的指针、字节数组的长度和容量等信息的结构体，并且提供了很多字符串相关的函数。
 
 ==它跟`&str`类型的主要区别是，它有管理内存空间的权力==。
 关于“所有权”和“借用”的关系，在本书第二部分会详细讲解。

docs/附录 词汇表.md

@@ -26,7 +26,7 @@
 | Fat Pointer                | 胖指针，即还携带额外信息的指针  |
 | Feature Gate               | 功能开关              |
 | FFI                        | Foreign Function Interface  |
-| Fn/FnMut/FnOnce            | 闭包相关的系列 trait  |
+|  Fn/FnMut/FnOnce           | 闭包相关的系列 trait  |
 |  Generic                   | 泛型            |
 |  Higher Rank Lifetime      | 高阶生命周期        |
 |  Higher Rank Trait Bounds  | 高阶 trait 约束  |