AlexZhang

建议读者在阅读本文之前，先学习 “提示指南” (https://www.promptingguide.ai/zh)，以便更好地理解。还建议使用 GPT-4 来构建该系统，但如果 GPT-4 不可用，也可以使用 GPT-3.5 来创建该系统，尽管 GPT-4 更加准确。此外，该系统也可以应用于其他编程语言。

最近，我一直在尝试 ChatGPT 和 Midjourney 等 AI 技术，试图体验成为一名年薪六位数的提示工程师的感觉。直到本周，我才发现 GPT-4 对学习 Rust 代码是多么有帮助。因此，我尝试创建这个 Rust 学习系统，我将其命名为 “RustChat” (https://github.com/ZhangHanDong/rustchat)，并在 GitHub 上创建了一个仓库，供其他人参与。

在学习 Rust 时，拥有一个可以提供问题以测试我们知识并给出准确答案和解释的系统将是非常好的。或者，当我们不知道该做什么项目来练习时，它可以推荐项目想法。现在，借助 AI，我们可以创建这样一个神奇而有用的系统。

RustChat 介绍：终极 Rust 学习 “魔法” 系统#

首先，让我们谈谈这个想法。由于我们想要一个命令提示模式，我们应该设计命令格式，就像设计程序 API 一样。

值得注意的是，尽管这个想法看起来简单，但这是经过大量实验的结果。之前失败的设计导致一个新命令破坏了旧的 GPT 设置，造成了混淆。

“魔法” 设计#

以下是我想要实现的一些命令提示示例：

work               // "work" 是主命令，表示工作级别的 Rust 问题
work -tech trait   // "-tech" 表示一个主命令，意味着输出指定“trait”内容的工作级别概念解释并提供代码示例
work -tech --cn trait // "--cn" 表示一个次命令，意味着以中文输出主命令和主命令指定的内容
work -type --en eBPF  // "-type" 表示一个主命令，意味着输出指定内容“eBPF”的工作级别问题
work -idea --cn   // "-idea" 表示一个主命令，意味着输出与主命令级别对应的项目实践想法和思路供参考。“--cn”表示一个次命令，意味着以中文输出内容。

我计划将问题分为三个级别：

1. 工作级别。工作级别的问题涵盖编写 Rust 代码的基本和常见特性和知识。
2. 专业级别。专业级别涵盖 Rust 的专家级特性和知识。
3. 测验类型。测验类型专门设计用于测试容易混淆的 Rust 语言特性。

主命令分别对应这三个级别：

1. “work” 命令对应工作级别的问题。
2. “expert” 命令对应专业级别的问题。
3. “quiz” 命令对应测验级别的问题。
4. “answer” 命令用于指定要回答的问题数量。

接下来，让我们介绍主命令。主命令可以与主命令以任何方式组合：

1. "-tech" 表示一个主命令，意味着输出指定内容的主命令级别的相应概念解释并提供示例。
2. "-type" 表示一个主命令，意味着输出指定内容的主命令级别的问题。
3. "-idea" 表示一个主命令，意味着输出与主命令级别对应的项目实践想法和思路供参考。
4. "-crate" 表示一个主命令，仅适用于 “work” 命令，意味着推荐指定内容的相应第三方 “crate”。
5. "-n" 表示一个主命令，仅适用于 “answer” 命令，意味着指定要回答的问题数量。

接下来，让我们介绍次命令，可以在主命令之后使用：

1. "--cn" 表示一个次命令，意味着以中文输出内容。
2. "--en" 表示一个次命令，意味着以英文输出内容。
3. "--jp" 表示一个次命令，意味着以日文输出内容。

因此，以下是该学习系统应支持的命令：

work               // "work" 是主命令，表示工作级别的 Rust 问题
work -tech trait   // "-tech" 表示一个主命令，意味着输出指定“trait”内容的工作级别概念解释并提供代码示例
work -tech --cn trait // "--cn" 表示一个次命令，意味着以中文输出主命令和主命令指定的内容
work -type --en eBPF  // "-type" 表示一个主命令，意味着输出指定内容“eBPF”的工作级别问题
work -crate eBPF   // "-crate" 表示一个主命令，意味着推荐指定内容“eBPF”的第三方“crate”
work -idea --cn   // "-idea" 表示一个主命令，意味着输出与主命令级别对应的项目实践想法和思路供参考。“--cn”表示一个次命令，意味着以中文输出内容。
answer -n 2 ,// "-n" 表示一个主命令，仅适用于“answer”命令，意味着回答此命令之前的两个问题
expert               // "expert" 是主命令，表示专业级别的 Rust 问题
expert -tech trait   // "-tech" 表示一个主命令，意味着输出指定“trait”内容的专业级别概念解释并提供代码示例
expert -tech --cn trait // "--cn" 表示一个次命令，意味着以中文输出主命令和主命令指定的内容
expert -type --en eBPF  // "-type" 表示一个主命令，意味着输出指定内容“eBPF”的专业级别问题
expert -idea --cn   // "-idea" 表示一个主命令，意味着输出与主命令级别对应的项目实践想法和思路供参考。“--cn”表示一个次命令，意味着以中文输出内容。
quiz               // "quiz" 是主命令，表示 Rust 测验问题
quiz -tech trait   // "-tech" 表示一个主命令，意味着输出指定“trait”内容的测验级别概念解释并提供代码示例
quiz -tech --cn trait // "--cn" 表示一个次命令，意味着以中文输出主命令和主命令指定的内容
quiz -type --en eBPF  // "-type" 表示一个主命令，意味着输出指定内容“eBPF”的测验级别问题
quiz -idea --cn   // "-idea" 表示一个主命令，意味着输出与主命令级别对应的项目实践想法和思路供参考。“--cn”表示一个次命令，意味着以中文输出内容。

构建提示#

接下来，我们将构建一个提示。为了确保 GPT-4 能够充分理解设计的 “魔法”，我们应该采用 “整体到细节” 的方法逐步 “喂” 它。

1. 设置主命令

作为 Rust 专家，我需要你的帮助，根据我的要求生成 Rust 问题。默认情况下，问题包括一个选择题和一个编码问题。问题默认以中文输出，除非指定相应的次命令来告诉你问题的数量。

问题分为三个级别：

1. 工作级别。工作级别的问题涵盖初学者和日常使用的 Rust 代码编写的常见特性和知识。
2. 专业级别。专业级别涵盖 Rust 的专家特性和知识。
3. 测验类型。测验类型专门测试容易混淆的 Rust 语言特性。

主命令分别对应这三个级别：

1. “work” 命令，对应工作级别的问题。
2. “expert” 命令，对应专业级别的问题。
3. “quiz” 命令，对应测验级别的问题。
4. “anwser” 命令，用于指定要回答的问题数量。

2. 设置次命令

接下来，让我们介绍主命令，可以与主命令组合使用：
1. "-tech"，表示一个主命令，意味着应为指定内容输出相应的主命令级别概念解释，并附上示例。
2. "-type"，表示一个主命令，意味着应为指定内容输出相应的主命令级别问题。
3. "-idea"，表示一个主命令，意味着应为参考输出相应的主命令级别项目实践想法和策略。
4. "-crate"，表示一个主命令，意味着应为指定内容推荐相应的第三方 crate。
5. "-n"，表示一个主命令，意味着需要指定要回答的问题数量并提供答案的解释。如果使用其他主命令，则限制生成的问题数量。

3. 设置次级命令

接下来，让我们介绍次命令，可以在主命令之后使用：
1. "--cn"，表示一个次命令，意味着应以中文输出内容。
2. "--en"，表示一个次命令，意味着应以英文输出内容。
3. "--jp"，表示一个次命令，意味着应以日文输出内容。

4. 添加修改命令的定义

设计这个命令系统如此详细的原因是为了方便添加和修改命令。否则，GPT-4 会感到困惑。

以下是修改命令的示例：

修改主命令：

"-n"，表示一个主命令，意味着需要指定要回答的问题数量并提供答案的解释。如果使用其他主命令，则限制生成的问题数量。

以下是添加说明的示例：

添加主说明： explain，意味着提供指定 Rust 代码的详细解释。debug，意味着帮助查找代码错误并根据给定的编译器错误提示提供修正后的代码。

注意：explain 本身就有解释的意思，因此即使未设置此主说明，GPT 也能识别这个词。在大多数情况下，GPT 也可以识别 cn 并通过使用 explain --cn 输出中文。

用法：

debug  

fn add(a: i32, b: i32) -> i32 {   
	(a + b) as i64 
}  

error:  返回类型不匹配

让 GPT 输出 “魔法” 系统手册#

最后，让 GPT 帮助您将所有说明整理成一个 markdown 表格：

请帮助我将主命令、次命令和三级命令及其功能整理成一个 markdown 表格。

它将输出以下表格：

“魔法” 系统用法#

现在我们的 “魔法” 系统已经启动并运行，我们可以通过组合主命令、一级命令和二级命令来实现预期的结果。

我们可以用它来实现以下功能：

• 生成不同级别的 Rust 问题和答案以测试我们的知识
• 指定 Rust 语言特性以生成相应的问题
• 让它推荐实践项目
• 让它回答我们自己生成的问题
• 指定输出内容的自然语言

生成工作级别问题#

work

GPT-4:

以下是两个工作级别的 Rust 问题，一个选择题和一个编码问题。

选择题：

在 Rust 中，哪个关键字用于声明不可变变量？ A. let B. mut C. const D. static

编码问题： 2. 请编写一个 Rust 函数 find_max，该函数接受一个整数向量作为参数，并返回向量中的最大值。如果向量为空，则返回 None。函数签名如下：

fn find_max(numbers: Vec<i32>) -> Option<i32> {
    // 在此处编写代码
}

生成指定数量的工作级别问题#

复制代码

work -n 3

GPT-4:

GPT 理解 -n 需要解释问题，这可以通过指令定义进行修改。

以下是三个工作级别的 Rust 问题，每个问题由一个选择题和一个编码实现问题组成：

问题 1：

在 Rust 中，哪个关键字用于声明不可变变量？

A. let B. mut C. const D. static

答案：A. let

解释：在 Rust 中，使用 let 关键字声明不可变变量。不可变意味着变量的值在声明后不能更改。如果需要声明一个可变变量，可以使用 let mut。const 和 static 关键字用于声明常量，其中 const 是编译时常量，而 static 是在运行时全局分配的变量。

问题 2：

编写一个名为 calculate_average 的 Rust 函数，该函数接受一个整数向量作为输入，并返回这些数字的平均值。如果向量为空，则返回 None。函数签名应如下所示：

rustCopy code

fn calculate_average(numbers: Vec<i32>) -> Option<f32> { // 在此处编写代码 }

问题 3：

在 Rust 中，String 和 &str 之间有什么区别？

A. String 是固定大小的字符串，而 &str 是可变大小的字符串。 B. String 是不可变字符串，而 &str 是可变字符串。 C. String 是堆分配的字符串，而 &str 是栈分配的字符串。 D. String 是拥有的字符串，而 &str 是借用的字符串。

答案：D. String 是拥有的字符串，而 &str 是借用的字符串。

解释：在 Rust 中，String 是一种表示堆分配的、可增长的、可变的 Unicode 字符序列的类型。&str 是对字符串切片的引用，它是对包含 Unicode 标量值序列的内存块的固定大小视图。String 拥有它使用的内存，而 &str 从其他来源借用内存。

生成基于指定内容的问题#

work -type algorithm

GPT-4:

以下是两个与算法相关的工作级别 Rust 问题，一个选择题和一个编码问题。

选择题：

1. 在 Rust 中，哪个方法用于对向量执行就地排序（即不创建新向量）以进行排序算法？

A. sort B. sorted C. sort_by D. sort_unstable

编码问题：

2. 请编写一个 Rust 函数 merge_sorted_arrays，该函数接受两个已排序的整数向量作为参数，并将它们合并为一个新的已排序向量。示例函数签名如下：

fn merge_sorted_arrays(a: Vec<i32>, b: Vec<i32>) -> Vec<i32> {
    // 在此处编写代码
}

为了防止 GPT-4 生成相同的问题，您可以通过使用以下命令更改主题：

work -type trait change

将主命令更改为 expert

expert -type trait

GPT-4:

以下是两个与 traits 相关的工作级别 Rust 问题，一个选择题和一个编码问题。

选择题：

1. 在 Rust 中，关于 trait 对象和静态调度的说法哪个是正确的？

A. Trait 对象实现静态调度，性能优于动态调度。 B. 静态调度使用 trait 对象，性能优于动态调度。 C. 静态调度使用单态化在编译时确定具体类型，性能优于动态调度。 D. 动态调度使用单态化在编译时确定具体类型，性能优于静态调度。

编码问题：

2. 请实现一个名为 Drawable 的 trait，其中包含一个名为 draw 的方法。然后，为 Circle 和 Rectangle 结构体实现 Drawable trait。最后，创建一个包含 Circle 和 Rectangle 的向量，并通过迭代向量并调用 draw 方法来绘制它们。示例代码结构如下：

trait Drawable {
    // 在此处编写代码
}

struct Circle {
    // 在此处编写代码
}

struct Rectangle {
    // 在此处编写代码
}

// 在此处为 Circle 和 Rectangle 实现 Drawable trait

fn main() {
    // 在此处编写代码以创建 Drawable 向量并通过调用 draw 方法绘制它们
}

仅指定 “编码实现” 类型的问题：

work -n 1 -type ffi coding implementation

这是一个与 FFI（外部函数接口）相关的工作级别 Rust 问题，提供了一个编码实现问题及其答案和解释。

编码问题：

1. 使用 Rust 的 FFI（外部函数接口）功能，编写一个名为 rust_add 的函数，该函数在 C 语言中添加两个 int 类型的整数并返回结果。提供该函数的相应 C 函数声明。示例代码结构如下：

// 在此处编写您的 Rust 代码

/*
// 提供 C 函数声明
extern "C" {
    // ...
}
*/

fn main() {
    // 在此处编写测试代码
}

答案：

// Rust 代码
#[no_mangle]
pub extern "C" fn rust_add(a: i32, b: i32) -> i32 {
    a + b
}

/*
// C 函数声明
#include <stdint.h>

extern int32_t rust_add(int32_t a, int32_t b);
*/

fn main() {
    // 由于需要在 C 语言环境中编译和调用，因此无法直接在此处测试。
}

解释：首先，我们定义了一个名为 rust_add 的函数，该函数接受两个 i32 类型的参数并返回它们的和。为了允许 C 代码调用此函数，我们使用 #[no_mangle] 属性来防止编译器重命名函数名。然后，我们使用 pub extern "C" 关键字将此函数的 ABI（应用程序二进制接口）指定为 C 风格。

接下来，我们提供了 C 函数声明。请注意，C 中的 int 类型在不同平台和编译器上可能具有不同的大小，因此我们在 C 中使用 int32_t 类型以确保与 Rust 中的 i32 类型匹配。这需要包含 stdint.h 头文件。

在 main 函数中，我们无法直接测试此 FFI 函数，因为它需要在 C 语言环境中编译和调用。您可以创建一个简单的 C 语言程序，将 Rust 编译为动态库或静态库，将其链接到 C 语言程序中，然后调用 rust_add 函数进行测试。

我不确定为什么有时它会同时提供答案和解释。

推荐实践项目#

work -idea

GPT-4:

以下是一些工作级别的 Rust 项目的想法和建议，供您练习：

1. 命令行工具：创建一个命令行工具，用于处理日常任务，例如批量重命名文件、下载网络资源或解析日志文件。您可以使用 clap 或 structopt 库来处理命令行参数。

2. Web 服务器：使用 Rust 编写一个简单的多线程 Web 服务器，以处理 HTTP 请求并提供静态或动态内容。您可以使用 hyper 和 tokio 库来实现异步 I/O 和 HTTP 功能。

3. 网络爬虫：编写一个网络爬虫，从指定网站获取内容并解析出所需信息。您可以使用 reqwest 库来处理网络请求，并使用 select.rs 库来解析 HTML 文档。

4. 聊天服务器和客户端：创建一个聊天服务器和客户端，允许多个用户通过 TCP 连接实时通信。您可以使用 tokio 库来实现异步 I/O 和多线程功能。

5. 文件加密工具：实现一个简单的文件加密和解密工具，以保护用户隐私数据。您可以使用 rust-crypto 或 ring 库来实现加密算法。

6. 文本编辑器：开发一个简单的文本编辑器，支持基本的文本编辑功能，例如打开、保存、搜索和替换。您可以使用 crossterm 或 termion 库来实现跨平台终端界面。

您可以指定关键字 “idea”：

work -idea cli gpt

GPT-4:

以下是一些使用 Rust 创建命令行界面（CLI）的 GPT 工具项目的想法和建议，供您参考：

项目名称：GPT-CLI

项目概述：创建一个 CLI 工具，允许用户通过输入文本与 GPT 模型进行交互，并获得模型生成的文本。该工具可用于各种用途，例如写作辅助、编程问题解决、自动电子邮件回复等。

主要特性：

1. 文本输入：允许用户输入文本以用作 GPT 模型的输入。
2. GPT 模型集成：集成 GPT 模型（例如 OpenAI 的 GPT-3 或自训练模型），并调用其 API 根据用户输入生成文本。
3. 结果显示：将 GPT 模型生成的文本显示给用户。
4. 保存功能：允许用户将生成的文本结果保存到指定文件。

推荐的库和工具：

1. 命令行参数处理：使用 clap 或 structopt 库来处理命令行参数。
2. HTTP 请求库：使用 reqwest 库来处理与 GPT 模型 API 的网络请求。
3. 异步编程：使用 tokio 或 async-std 库来实现异步编程以提高性能。
4. 环境变量管理：使用 dotenv 库来管理敏感信息，例如 API 密钥。

开发步骤：

1. 设计命令行参数结构，例如输入文本和保存文件路径。
2. 使用 clap 或 structopt 库解析命令行参数。
3. 集成 GPT 模型 API，例如 OpenAI 的 GPT-3，并设置 API 密钥和请求参数。
4. 使用 reqwest 库发送 HTTP 请求并获取 GPT 模型生成的文本。
5. 处理 GPT 模型返回的结果并将其显示给用户。
6. 实现将生成的文本保存到文件的功能。
7. 测试和优化程序。

回答生成的问题#

expert -type struct

GPT-4:

以下是两个与结构体相关的专业级 Rust 问题，一个选择题和一个代码实现。

选择题：

1. 关于在 Rust 中为结构体派生 PartialEq 和 Eq trait，哪个说法是正确的？

A. 所有结构体都必须实现 PartialEq 和 Eq trait。 B. 结构体只需实现 PartialEq trait，Eq trait 将自动派生。 C. 结构体可以选择派生 PartialEq 和 Eq trait，但只有在其所有字段实现这些 trait 的情况下。 D. 在为结构体派生 PartialEq 和 Eq trait 时，您不需要考虑其字段的 trait 实现。

代码实现问题：

2. 请创建一个名为 Color 的结构体，其中包含三个 u8 字段：red、green 和 blue。为 Color 结构体实现 PartialEq trait，以比较两个 Color 实例是否相等。如果两个 Color 实例的 red、green 和 blue 字段值之间的差异小于或等于 10，则认为它们相等。示例代码结构如下：

use std::cmp::PartialEq;

struct Color {
    // 在此处编写代码
}

impl PartialEq for Color {
    // 在此处编写代码
}

fn main() {
    // 在此处创建两个 Color 实例并比较它们是否相等
}

answer -n 2

根据您的请求，我将为前两个问题提供答案和解释。

选择题答案和解释：

1. 关于在 Rust 中为结构体派生 PartialEq 和 Eq trait，哪个说法是正确的？

答案：C. 结构体可以选择派生 PartialEq 和 Eq trait，但只有在其所有字段实现这些 trait 的情况下。

解释：在 Rust 中，结构体可以选择性地为结构体实例的相等比较派生 PartialEq 和 Eq trait。然而，为结构体派生这些 trait 的前提是其所有字段都已经实现了这些 trait。如果结构体的任何字段未实现这些 trait，则无法为该结构体派生 PartialEq 和 Eq trait。

代码实现答案和解释：

2. 请创建一个名为 Color 的结构体，其中包含三个 u8 字段：red、green 和 blue。为 Color 结构体实现 PartialEq trait，以比较两个 Color 实例是否相等。如果两个 Color 实例的 red、green 和 blue 字段值之间的差异小于或等于 10，则认为它们相等。示例代码结构如下：

答案：

use std::cmp::PartialEq;

struct Color {
    red: u8,
    green: u8,
    blue: u8,
}

impl PartialEq for Color {
    fn eq(&self, other: &Self) -> bool {
        (self.red as i32 - other.red as i32).abs() <= 10 &&
        (self.green as i32 - other.green as i32).abs() <= 10 &&
        (self.blue as i32 - other.blue as i32).abs() <= 10
    }
}

fn main() {
    let color1 = Color { red: 255, green: 128, blue: 64 };
    let color2 = Color { red: 250, green: 130, blue: 70 };

    println!("Color1 equals Color2: {}", color1 == color2);
}

解释：首先，我们定义了 Color 结构体，并添加了三个 u8 类型的字段：red、green 和 blue。接下来，我们为 Color 结构体实现了 PartialEq trait，并定义了 eq 方法。在 eq 方法中，我们比较两个 Color 实例的 red、green 和 blue 字段的绝对差值，以查看它们是否小于或等于 10。如果满足此条件，则认为这两个 Color 实例相等。最后，在 main 函数中，我们创建了两个 Color 实例，并使用 == 运算符比较它们是否相等。

推荐的 crate#

expert -crate eBPF

GPT-4:

好的，以下是一些与 eBPF 主题相关的高级问题和推荐的第三方 crates：

问题：

1. 请详细解释 Rust 中 eBPF 技术的原理和应用场景。
2. 在 Rust 中，如何使用 libbpf-rs crate 编写高效的 eBPF 程序？
3. 在 Rust 中，如何使用 redbpf-probes crate 实现自定义的 eBPF 事件探针？

推荐的第三方 crates：

• libbpf-rs：一个用于编写和加载 eBPF 程序的 Rust crate。
• redbpf-probes：一个用于编写自定义 eBPF 事件探针的 Rust crate。

注意：eBPF 技术需要在支持它的内核上运行。如果您的系统不支持 eBPF，您可能无法完成此任务。

请求以日语输出：#

work -tech lifetime --jp

GPT-4:

以下是与ライフタイムに関連する技術概念の説明と例を日本語で提供します。

ライフタイムとは、Rust でメモリ管理や参照の安全性を担保するための概念です。ライフタイムは、コンパイル時に参照の有効性を検証し、参照されるオブジェクトが参照されている期間中に破棄されないことを保証します。

例:

fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}

fn main() {
    let s1 = String::from("長い文字列");
    let s2 = String::from("短い");

    let result = longest(&s1, &s2);
    println!("最も長い文字列は: {}", result);
}

上記の例では、longest関数は 2 つの文字列のスライスを引数に取り、最も長いものを返します。ライフタイムパラメータ'aは、入力参照と戻り値の参照が同じライフタイムを持つことを示しています。

longest関数は、参照されるオブジェクトが参照されている期間中に破棄されないことを保証するために、ライフタイムを使用しています。これにより、ダングリングポインタや他のメモリ安全性に関連する問題を防止できます。

请求以英文输出：

work -tech --en lifetime

次命令的位置不会影响其理解。

以下是与 Rust 中的生命周期相关的技术概念的解释和示例，以英文提供。

Lifetimes are a concept in Rust for managing memory and ensuring reference safety. Lifetimes are used to verify the validity of references at compile-time, ensuring that the object being referenced is not destroyed while it is still being referenced.

Example:

fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}

fn main() {
    let s1 = String::from("long string");
    let s2 = String::from("short");

    let result = longest(&s1, &s2);
    println!("The longest string is: {}", result);
}

In the example above, the longest function takes two string slices as arguments and returns the longer one. The lifetime parameter 'a indicates that the input references and the returned reference have the same lifetime.

The longest function uses lifetimes to ensure that the object being referenced is not destroyed while it is still being referenced, preventing dangling pointers and other memory safety-related issues.

总结#

建立这个 “魔法” 学习系统并不困难，但它应该对日常 Rust 学习有很大帮助。最后，我们希望每个人都能分享您开发的有用命令或 GPT-4 生成的值得记录的 Rust 问题和答案到 RustChat GitHub 仓库，形成一个问答知识库，以帮助更多的 Rust 学习者。

感谢您的阅读。