编辑“︁Rust泛型枚举”︁

= Rust泛型枚举 =

'''泛型枚举'''是Rust中结合泛型（Generics）与枚举（Enums）特性的强大工具，允许开发者定义可适应多种数据类型的枚举变体。通过泛型枚举，可以编写更灵活、可复用的代码，同时保持类型安全。

== 基本概念 ==

在Rust中，枚举（Enum）是一种可以包含多个变体的数据类型。当枚举的变体需要处理不同类型的数据时，泛型枚举就派上用场了。泛型参数用尖括号（<T>）声明，表示类型占位符，实际使用时由具体类型替换。

=== 泛型枚举的定义语法 ===
泛型枚举的定义方式与普通枚举类似，但在枚举名后需添加泛型参数：
<syntaxhighlight lang="rust">
enum MyGenericEnum<T> {
    VariantA(T),
    VariantB(T, T),
    VariantC,
}
</syntaxhighlight>
这里，<code>T</code>是泛型类型参数，<code>VariantA</code>和<code>VariantB</code>可以存储类型为<code>T</code>的值。

== 代码示例 ==

=== 基础示例 ===
以下是一个简单的泛型枚举<code>ResultLike</code>，模拟Rust标准库中的<code>Result</code>类型：
<syntaxhighlight lang="rust">
enum ResultLike<T, E> {
    Ok(T),
    Err(E),
}

fn divide(x: f64, y: f64) -> ResultLike<f64, String> {
    if y == 0.0 {
        ResultLike::Err(String::from("Division by zero"))
    } else {
        ResultLike::Ok(x / y)
    }
}

fn main() {
    let result = divide(10.0, 2.0);
    match result {
        ResultLike::Ok(val) => println!("Result: {}", val),
        ResultLike::Err(e) => println!("Error: {}", e),
    }
}
</syntaxhighlight>
'''输出：'''
<pre>
Result: 5
</pre>

=== 复杂示例：二叉树 ===
泛型枚举常用于数据结构实现。以下是用泛型枚举定义的二叉树：
<syntaxhighlight lang="rust">
enum BinaryTree<T> {
    Empty,
    Node(T, Box<BinaryTree<T>>, Box<BinaryTree<T>>),
}

impl<T> BinaryTree<T> {
    fn new() -> Self {
        BinaryTree::Empty
    }

    fn insert(&mut self, value: T) where T: PartialOrd {
        match self {
            BinaryTree::Empty => {
                *self = BinaryTree::Node(
                    value,
                    Box::new(BinaryTree::Empty),
                    Box::new(BinaryTree::Empty),
                );
            }
            BinaryTree::Node(v, left, right) => {
                if value < *v {
                    left.insert(value);
                } else {
                    right.insert(value);
                }
            }
        }
    }
}
</syntaxhighlight>

== 实际应用场景 ==

=== 错误处理 ===
Rust标准库中的<code>Result<T, E></code>是最著名的泛型枚举，用于处理可能失败的操作：
<syntaxhighlight lang="rust">
fn read_file(path: &str) -> Result<String, std::io::Error> {
    std::fs::read_to_string(path)
}
</syntaxhighlight>

=== 状态机 ===
泛型枚举适合表示状态机的不同状态：
<syntaxhighlight lang="rust">
enum State<T> {
    Initial,
    Processing(T),
    Completed(T),
    Failed(String),
}
</syntaxhighlight>

== 类型约束与特质绑定 ==

可以为泛型枚举的类型参数添加特质约束（Trait Bounds）：
<syntaxhighlight lang="rust">
enum DisplayableResult<T: std::fmt::Display, E: std::fmt::Display> {
    Success(T),
    Failure(E),
}
</syntaxhighlight>

== 高级主题：泛型枚举的匹配 ==

使用模式匹配时，泛型参数会保留其类型信息：
<syntaxhighlight lang="rust">
fn handle_result<T, E>(result: ResultLike<T, E>)
where
    T: std::fmt::Display,
    E: std::fmt::Display,
{
    match result {
        ResultLike::Ok(x) => println!("Value: {}", x),
        ResultLike::Err(e) => println!("Error: {}", e),
    }
}
</syntaxhighlight>

== 性能考虑 ==

Rust的泛型枚举在编译时会被'''单态化'''（Monomorphization），即编译器会为每个具体类型生成专用代码。这意味着：
* 运行时无额外开销
* 二进制文件可能增大

== 可视化：泛型枚举内存布局 ==
<mermaid>
classDiagram
    class ResultLike~T, E~ {
        <<enum>>
        Ok(T)
        Err(E)
    }
    note for ResultLike "内存布局取决于具体类型\nT和E的实际大小"
</mermaid>

== 数学表示 ==
泛型枚举可以形式化表示为：
<math>
\text{Enum}(T_1, T_2, \dots, T_n) = C_1(T_{1,1}, \dots) \cup C_2(T_{2,1}, \dots) \cup \dots \cup C_k(\dots)
</math>
其中<math>C_i</math>是枚举变体，<math>T_{i,j}</math>是泛型类型参数。

== 总结 ==
* 泛型枚举允许创建可重用、类型安全的枚举定义
* 广泛应用于错误处理、数据结构和状态机等场景
* 通过特质约束可以限制泛型参数的能力
* 编译时单态化保证零成本抽象

通过合理使用泛型枚举，可以显著提升Rust代码的表达能力和类型安全性。

[[Category:编程语言]]
[[Category:Rust]]
[[Category:Rust泛型与特质]]