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:  Return type mismatch

讓 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，該 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 代碼中定義了一個名為 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. 網絡服務器：使用 Rust 編寫一個簡單的多線程網絡服務器，以處理 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

次要指令的位置不影響其理解。

Below is an explanation and example of the technical concept of lifetimes in Rust, provided in English.

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 學習者。

謝謝您的閱讀。