Rust 宏實戰：深入理解重複語法與自定義derive宏

Rust 宏系統提供強大的超程式設計能力，允許開發者在編譯期生成程式碼，提升程式碼的表達力和可重用性。本文將深入探討 Rust 宏的進階用法，包含重複語法與自定義 derive 宏的實作。重複語法如 ($($element:expr),*) 和 $()+, 可用於處理可變數量的輸入，簡化類似 vector! 宏的定義。理解 derive 宏的機制則能讓我們自行定義類似 #[derive(Debug)] 的功能，例如建立 map! 宏簡化 HashMap 的初始化，或設計 Info 宏自動為結構體實作特定 trait，從而減少重複程式碼並提高開發效率。

重複

在建立宏時，我們可以使用重複的語法來簡化程式碼。例如，在 vector! 宏中，我們使用了 ($($element: expr), *) 來表示零或多個元素。這種語法可以概括為 $()*,，它允許我們在宏中新增重複的功能。

重複的語法有三種：

*：重複零或多次
+：重複一次或多次
?：重複零或一次

建立一個執行多個函式的宏

現在，我們來建立一個宏，名為 multi!，它可以執行多個函式。這個宏需要一個或多個函式的識別符號，所以我們使用 ident 型別來表示引數。同時，我們需要使用 + 來表示重複一次或多次。

macro_rules! multi {
    ($($f: ident), +) => {{
        $(
            $f();
        )+
    }};
}

在這個宏中，我們使用 $( $f(); )+ 來重複執行函式。這個語法會將每個函式的識別符號替換為實際的函式呼叫。

測試宏

現在，我們來定義一些簡單的函式，然後使用 multi! 宏來執行它們。

fn hello() {
    println!("Hello");
}

fn bye() {
    println!("Bye");
}

fn hello_bye() {
    hello();
    bye();
}

fn main() {
    multi![hello, bye, hello_bye];
}

如果我們編譯和執行這個程式，輸出應該是：

Hello
Bye
Hello
Bye

這個例子展示瞭如何建立和使用宏來簡化程式碼和提高可重用性。

內容解密：

在上面的程式碼中，我們定義了一個 multi! 宏，它可以執行多個函式。這個宏使用 ident 型別來表示函式的識別符號，然後使用 + 來表示重複一次或多次。透過這個宏，我們可以簡化程式碼和提高可重用性。

圖表翻譯：

  flowchart TD
    A[定義宏] --> B[使用宏]
    B --> C[執行函式]
    C --> D[輸出結果]
    D --> E[結束]

這個圖表展示了宏的建立和應用過程。首先，我們定義一個宏，然後使用它來執行函式，最後輸出結果。

使用Rust建立自定義HashMap宏

在Rust中，宏（macro）是一種強大的工具，允許我們擴充套件語言本身。這裡，我們將建立一個自定義的宏，稱為map!，用於建立一個HashMap並插入鍵值對。

宏定義

首先，讓我們定義宏map!：

macro_rules! map {
    ($($key: expr => $value: expr),*) => {{
        let mut map = std::collections::HashMap::new();
        $(
            map.insert($key, $value);
        )*
        map
    }};
}

在這個定義中，$($key: expr => $value: expr),*是一個模式，匹配零個或多個鍵值對。每個鍵值對由=>分隔，鍵和值都是表示式（expr）。

宏體

在宏體中，我們建立了一個新的可變HashMap，並將其指定給map。然後，我們使用$()重複插入鍵值對到map中。最後，我們傳回map。

測試宏

現在，讓我們測試一下宏：

fn main() {
    let student_grades = map! {
        "alice" => 87,
        "john" => 67,
        "kyle" => 56
    };

    println!("{:?}", student_grades);
}

這將輸出：

{"alice": 87, "john": 67, "kyle": 56}

這證明瞭我們的宏map!工作正常。

Mermaid圖表

以下是宏map!的Mermaid圖表：

  graph LR
    A[定義宏map!] --> B[建立HashMap]
    B --> C[插入鍵值對]
    C --> D[傳回HashMap]
    D --> E[測試宏]
    E --> F[輸出結果]

圖表翻譯

這個圖表展示了宏map!的工作流程。首先，我們定義宏map!。然後，我們建立一個新的HashMap，並插入鍵值對。最後，我們傳回HashMap，並測試宏以確保其工作正常。

Rust 宏的世界：從宣告到程式宏

在 Rust 中，宏（macro）是一種強大的工具，能夠讓我們在編譯時期生成程式碼。宣告宏（declarative macro）和程式宏（procedural macro）是 Rust 中兩種不同的宏型別。在這篇文章中，我們將探討程式宏的世界，包括其種類、使用方法和實際應用。

宣告宏 vs 程式宏

宣告宏是一種簡單的宏，使用 macro_rules! 關鍵字定義。它們主要用於簡單的程式碼生成，例如生成一個簡單的函式或結構體。另一方面，程式宏是一種更強大的宏，能夠使用 Rust 的語法和 tokens 生成新的 Rust 程式碼。

程式宏的種類

程式宏有三種不同的型別：

Derive 宏：Derive 宏用於實作特徵（trait）於結構體或列舉上。例如，#[derive(Debug)] 會自動實作 Debug 特徵於結構體或列舉上。
Attribute 宏：Attribute 宏用於定義外部屬性（attribute），可以應用於專案（item）上。例如，#[get("/")] 會定義一個 GET 請求的路由。
Function-like 宏：Function-like 宏類似於函式，但輸入是 TokenStream，且使用宏呼叫運算子 (!) 呼叫。例如，sql!(SELECT * FROM table); 會生成一個 SQL 查詢。

使用程式宏

要使用程式宏，需要在 Cargo.toml 中新增 proc-macro 欄位，並使用 syn 和 quote 兩個 crates。syn 用於解析 Rust tokens 成語法樹，而 quote 用於生成新的 Rust 程式碼。

實際應用

在實際應用中，程式宏可以用於生成複雜的程式碼，例如自動實作特徵、生成 SQL 查詢或建立 Web 框架。使用 cargo-expand 工具，可以檢視宏在擴充套件後的程式碼。

內容解密：

在這篇文章中，我們探討了程式宏的世界，包括其種類、使用方法和實際應用。程式宏是一種強大的工具，能夠讓我們在編譯時期生成程式碼。透過瞭解程式宏的種類和使用方法，可以幫助我們更好地使用 Rust 並提高開發效率。

圖表翻譯：

  graph LR
    A[程式宏] --> B[Derive 宏]
    A --> C[Attribute 宏]
    A --> D[Function-like 宏]
    B --> E[實作特徵]
    C --> F[定義外部屬性]
    D --> G[生成程式碼]

這個圖表展示了程式宏的種類和其應用。程式宏可以分為三種：Derive 宏、Attribute 宏和 Function-like 宏。每種程式宏都有其特定的應用，例如實作特徵、定義外部屬性和生成程式碼。

瞭解Derive Macros的運作機制

在Rust中，Derive macros是一種強大的工具，讓我們可以自動實作特定的trait（特性）於struct或enum。這種機制可以節省我們的時間和精力，尤其是在處理大量的資料結構時。

Derive Macros的基本概念

Derive macros的基本思想是透過特定的attribute（屬性）來自動實作特定的trait。例如，當我們使用#[derive(Debug)] attribute時，Rust會自動為我們的struct或enum實作Debug trait。

實際範例

讓我們看一個簡單的範例。假設我們有一個struct Foo，它包含三個欄位：bar、baz和laz。

#[derive(Debug)]
struct Foo {
    bar: String,
    baz: u8,
    laz: Vec<i8>,
}

當我們使用cargo expand命令時，Rust會展開這個struct，並顯示出實際的實作。

struct Foo {
    bar: String,
    baz: u8,
    laz: Vec<i8>,
}

impl ::core::fmt::Debug for Foo {
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        match *self {
            Foo { bar: ref __self_0_0, baz: ref __self_0_1, laz: ref __self_0_2 } => {
                let debug_trait_builder = &mut ::core::fmt::Formatter::debug_struct(
                    f,
                    "Foo",
                );

                let _ = ::core::fmt::DebugStruct::field(
                    debug_trait_builder,
                    "bar",
                    &&(*__self_0_0),
                );
                // ...
            }
        }
    }
}

這個實作顯示了Rust如何自動為我們的struct實作Debug trait。這個過程涉及到建立一個Formatter物件，然後使用debug_struct方法來建立一個debug格式的字串。

自訂 Derive 宏：Info

在 Rust 中，derive 宏是一種強大的工具，允許我們自動實作特定的 trait 於 struct 或 enum 上。當我們使用 #[derive(Debug)] 來實作 Debug trait 時，Rust 會在編譯時自動擴充套件這個宏，實作必要的方法。下面，我們將建立自己的 derive 宏，名為 Info，它將實作 info() 方法，傳回一個包含 struct 名稱、欄位名稱和欄位型別的字串。

建立專案和函式庫

首先，讓我們建立一個新專案 info_demo，並在其中建立兩個函式庫：info 和 info_derive。

$ cargo new info_demo
$ cd info_demo
$ cargo new --lib info
$ cargo new --lib info_derive

然後，修改 Cargo.toml 檔案以新增依賴關係：

# info_demo/Cargo.toml
[dependencies]
info = { path = "info" }
info_derive = { path = "info_derive" }

實作 Info Trait

在 info 函式庫中，建立 lib.rs 檔案，定義 Info trait：

// info/lib.rs
pub trait Info {
    fn info(&self) -> String;
}

實作 Info Derive 宏

在 info_derive 函式庫中，建立 lib.rs 檔案，定義 Info derive 宏：

// info_derive/lib.rs
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput};

#[proc_macro_derive(Info)]
pub fn derive_info(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = input.ident;
    let fields = match input.data {
        syn::Data::Struct(ref data) => data.fields.iter(),
        _ => panic!("Only structs are supported"),
    };

    let field_strings = fields.map(|field| {
        let name = field.ident.as_ref().unwrap();
        let ty = field.ty;
        quote! {
            #name: #ty
        }
    });

    let expanded = quote! {
        impl Info for #name {
            fn info(&self) -> String {
                let mut s = String::new();
                s.push_str(&format!("Name: {}\n", #name));
                #(
                    s.push_str(&format!("- {}: {}\n", #field_strings));
                )*
                s
            }
        }
    };

    TokenStream::from(expanded)
}

測試 Info Derive 宏

現在，讓我們在 info_demo 專案中使用 Info derive 宏：

// info_demo/src/main.rs
use info::Info;

#[derive(Info)]
struct Person {
    name: String,
    age: u32,
    alive: bool,
}

fn main() {
    let person = Person {
        name: "John".to_string(),
        age: 30,
        alive: true,
    };
    println!("{}", person.info());
}

編譯並執行 info_demo 專案，輸出應該是：

Name: Person
- alive: bool
- name: String
- age: u32

這就是我們自訂的 Info derive 宏的基本實作。它可以自動實作 Info trait 於 struct 上，傳回一個包含 struct 名稱、欄位名稱和欄位型別的字串。

Rust 中的自訂特徵（Trait）與程式化巨集（Procedural Macro）

建立自訂特徵

首先，我們需要建立一個名為 Info 的特徵（trait），這個特徵將包含一個名為 info 的方法，該方法傳回一個字串。這個特徵的定義如下：

pub trait Info {
    fn info(&self) -> String;
}

建立程式化巨集

接下來，我們需要建立一個程式化巨集（procedural macro），這個巨集將被用於自動實作 Info 特徵。首先，我們需要在 Cargo.toml 中新增相應的依賴：

[lib]
proc-macro = true

[dependencies]
syn = { version = "1.0.102", features = ["extra-traits"] }
quote = "1.0.21"

然後，在 info_derive/src/lib.rs 中，我們可以開始建立程式化巨集：

extern crate proc_macro;
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, Data, DeriveInput, Fields};

#[proc_macro_derive(Info)]
pub fn info_derive(input: TokenStream) -> TokenStream {
    // ...
}

解析輸入

在 info_derive 函式中，我們首先需要解析輸入的 TokenStream：

let mut insert_tokens = Vec::new();
let parsed_input: DeriveInput = parse_macro_input!(input);
let identifier = parsed_input.ident;

處理結構體（Struct）

接下來，我們需要處理結構體（struct）的情況。首先，我們需要檢查輸入的資料型別是否為結構體：

match parsed_input.data {
    Data::Struct(ref s) => {
        // 處理結構體
    }
    _ => {
        // 不支援的資料型別
        panic!("Only structs are supported");
    }
}

生成程式碼

在處理結構體的程式碼中，我們需要生成實作 Info 特徵的程式碼。首先，我們需要生成一個 map 並插入結構體的識別符號：

insert_tokens.push(
    quote! {
        map.insert(
            "struct".to_string(),
            stringify!(#identifier).to_string()
        );
    }
);

完整程式碼

最終，完整的 info_derive 函式如下：

#[proc_macro_derive(Info)]
pub fn info_derive(input: TokenStream) -> TokenStream {
    let mut insert_tokens = Vec::new();
    let parsed_input: DeriveInput = parse_macro_input!(input);
    let identifier = parsed_input.ident;

    match parsed_input.data {
        Data::Struct(ref s) => {
            insert_tokens.push(
                quote! {
                    map.insert(
                        "struct".to_string(),
                        stringify!(#identifier).to_string()
                    );
                }
            );
        }
        _ => {
            panic!("Only structs are supported");
        }
    }

    // 生成實作 Info 特徵的程式碼
    let expanded = quote! {
        impl Info for #identifier {
            fn info(&self) -> String {
                // ...
            }
        }
    };

    TokenStream::from(expanded)
}

圖表翻譯：

  graph LR
    A[輸入 TokenStream] --> B[解析輸入]
    B --> C[處理結構體]
    C --> D[生成實作 Info 特徵的程式碼]
    D --> E[傳回 TokenStream]

實作 Info 特性於結構體

在實作 Info 特性於結構體的過程中，我們需要利用 Rust 的超程式設計能力，特別是 quote! 宏，來生成實作 Info 特性的程式碼。以下是關鍵步驟和程式碼片段：

解析輸入資料

首先，我們需要解析輸入資料，以確定它是一個結構體（Data::Struct）。如果不是，則會引發一個恐慌（panic）。

match parsed_input.data {
    Data::Struct(s) => {
        // 處理結構體
    }
    other => panic!("Info is not yet implemented for {:?}", other),
}

提取結構體欄位

對於結構體，我們使用 if let 陳述式來提取結構體的欄位，假設它們是以命名欄位（Fields::Named）的形式呈現。

if let Fields::Named(named_fields) = s.fields {
    let punc = named_fields.named;
    for field in punc {
        // 處理每個欄位
    }
}

處理每個欄位

對於每個欄位，我們需要提取其識別符號（ident）和資料型別（field_type），然後使用 quote! 宏生成程式碼，將這些資訊插入到一個對映（HashMap）中。

let ident = field.ident.unwrap();
let field_type = field.ty;

let insert_token = quote! {
    map.insert(
        stringify!(#ident).to_string(),
        stringify!(#field_type).to_string()
    );
};
insert_tokens.push(insert_token)

實作 Info 特性

現在，我們需要使用 quote! 宏生成實作 Info 特性的程式碼。這包括匯入必要的模組、定義實作 Info 特性的結構體，以及生成 info 方法的程式碼。

let tokens = quote! {
    use ::std::collections::HashMap;
    use ::info::Info;

    impl Info for #identifier {
        fn info(&self) -> String {
            let mut map = HashMap::new();
            let mut info_parts = Vec::new();

            // 插入欄位資訊到對映中
            #( #insert_tokens )*

            // 生成 info 方法的程式碼
            info_parts.push(format!("{}: {:?}", #ident, #field_type));
            info_parts.join(", ")
        }
    }
};

生成最終程式碼

最終，我們需要將生成的程式碼組合起來，形成實作 Info 特性的完整程式碼。

let final_code = quote! {
    #tokens
};

這個過程利用 Rust 的超程式設計能力，自動生成實作 Info 特性的程式碼，從而簡化了開發人員的工作。

Rust 宏實作自定義 Derive Trait

在 Rust 中，Derive Trait 是一種強大的工具，允許我們自動實作特定的 trait。這篇文章將介紹如何使用 Rust 宏實作自定義 Derive Trait。

宏的定義

首先，我們需要定義一個宏，該宏將會生成實作 Info trait 的程式碼。這個宏將會使用 proc-macro 來處理程式碼的生成。

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput};

#[proc_macro_derive(Info)]
pub fn derive_info(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = input.ident;
    let fields = input.data.fields();

    let mut info_parts = vec![];
    for field in fields {
        let field_name = field.ident.as_ref().unwrap();
        let field_type = field.ty;
        info_parts.push(quote! {
            #field_name: #field_type
        });
    }

    let expanded = quote! {
        impl Info for #name {
            fn info(&self) -> String {
                let mut map = std::collections::HashMap::new();
                map.insert("struct".to_string(), #name.to_string());
                #(
                    map.insert(#field_name.to_string(), #field_type.to_string());
                )*
                let name = map.remove("struct").unwrap();
                let mut info_parts = vec![];
                info_parts.push(format!("Name: {}", name));
                #(
                    info_parts.push(format!("\t - {}: {}", #field_name, #field_type));
                )*
                info_parts.join("\n")
            }
        }
    };

    TokenStream::from(expanded)
}

宏的使用

現在，我們可以使用這個宏來實作 Info trait。首先，我們需要在 Cargo.toml 中新增 proc-macro 的依賴：

[dependencies]
proc-macro2 = "1.0.43"
quote = "1.0.15"
syn = "1.0.93"

然後，我們可以在 src/main.rs 中使用這個宏：

use info_derive::Info;

#[derive(Info)]
struct Person {
    name: String,
    age: u32,
    alive: bool,
}

fn main() {
    let person = Person {
        name: "Mustafif".to_string(),
        age: 19,
        alive: true,
    };
    println!("{}", person.info());
}

結果

當我們執行這個程式時，我們可以看到以下輸出：

Name: Person
    - name: String
    - age: u32
    - alive: bool

這是因為我們的宏自動實作了 Info trait，並生成了相應的程式碼。

Attribute Macros 在 Rust 中的應用

Attribute Macros 是 Rust 中的一種程式化宏（Procedural Macros），它們可以用於修改或擴充套件 Rust 的語法。Attribute Macros 通常用於新增元資料（metadata）到 Rust 的程式碼中，例如新增特定的屬性或標籤到函式、結構體或模組上。

從技術架構視角來看，Rust 宏系統，尤其是程式宏，展現了其強大的超程式設計能力。本文深入探討了從宣告宏到程式宏的各種應用，包括重複語法、自定義 HashMap 宏、derive 宏以及 attribute 宏。分析顯示，程式宏能生成複雜程式碼，自動實作 trait、生成 SQL 查詢或建立 Web 框架等，極大提升開發效率。然而，程式宏的學習曲線較陡峭，需要深入理解 Rust 的語法樹和宏系統。展望未來，隨著 Rust 社群的蓬勃發展和更多實踐案例的出現，程式宏的應用場景將更加廣泛，相關工具和檔案也將更加完善。玄貓認為，程式宏是 Rust 語言的一大亮點，值得深入學習和探索，將有助於開發者編寫更簡潔、高效且可維護的程式碼。對於追求進階 Rust 開發的工程師，掌握程式宏將是提升程式碼品質和開發效率的關鍵一步。

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。