Rust 2026 经验谈 - 枚举与模式匹配新范式

1
enum HttpError {
2
    BadRequest,
3
    Unauthorized,
4
    NotFound,
5
    InternalServerError,
6
    // 未来可能新增：RateLimited, ServiceUnavailable, ...
7
}
8

9
fn user_facing_message(err: &HttpError) -> &'static str {
10
    match err {
11
        HttpError::BadRequest => "请求格式错误",
12
        HttpError::Unauthorized => "未授权",
13
        HttpError::NotFound => "资源未找到",
14
        _ => "服务器错误",  // 所有服务端错误统一处理
15
    }
16
}

1
// crate `http_lib`
2
#[non_exhaustive]
3
#[derive(Debug)]
4
pub enum StatusCode {
5
    Ok,
6
    NotFound,
7
    InternalError,
8
}
9

10
// crate `my_app`（依赖 http_lib）
11
fn handle_status(status: StatusCode) {
12
    match status {
13
        StatusCode::Ok => println!("success"),
14
        StatusCode::NotFound => println!("not found"),
15
        // ❌ 缺少 _：non_exhaustive 要求处理未知变体
16
        // StatusCode::InternalError => println!("error"),
17
        _ => println!("other status"),  // ✅ 必须有 _
18
    }
19
}

1
enum Value {
2
    Number(i32),
3
    Text(String),
4
}
5

6
// RFC 2008 之前：需要显式 ref
7
fn describe_old(v: &Value) -> &str {
8
    match v {
9
        &Value::Number(ref n) if *n > 0 => "positive",
10
        &Value::Number(_) => "non-positive",
11
        &Value::Text(ref s) if s.len() > 10 => "long text",
12
        &Value::Text(_) => "short text",
13
    }
14
}
15

16
// RFC 2008 之后：自动引用
17
fn describe_new(v: &Value) -> &str {
18
    match v {
19
        Value::Number(n) if *n > 0 => "positive",
20
        Value::Number(_) => "non-positive",
21
        Value::Text(s) if s.len() > 10 => "long text",
22
        Value::Text(_) => "short text",
23
    }
24
}

1
let v = Value::Number(42);
2

3
// ❌ 混用不同引用层级
4
match &v {
5
    Value::Number(n) => {  // n: &i32（自动 ref）
6
        println!("{}", n);
7
    }
8
}
9

10
// ✅ 显式标注更清晰
11
match &v {
12
    Value::Number(ref n) => {  // n: &i32（显式 ref）
13
        println!("{}", n);
14
    }
15
}

1
struct Request {
2
    headers: std::collections::HashMap<String, String>,
3
    body: Option<String>,
4
}
5

6
fn handle(req: &Request) -> Result<String, String> {
7
    let Some(content_type) = req.headers.get("content-type") else {
8
        return Err("missing content-type".into());
9
    };
10

11
    let Some(body) = &req.body else {
12
        return Err("missing body".into());
13
    };
14

15
    if content_type != "application/json" {
16
        return Err(format!("unsupported content-type: {}", content_type));
17
    }
18

19
    Ok(body.clone())
20
}

1
// 传统方式 1：嵌套 if-let（金字塔代码）
2
fn handle_old1(req: &Request) -> Result<String, String> {
3
    if let Some(content_type) = req.headers.get("content-type") {
4
        if let Some(body) = &req.body {
5
            if content_type == "application/json" {
6
                Ok(body.clone())
7
            } else {
8
                Err(format!("unsupported: {}", content_type))
9
            }
10
        } else {
11
            Err("missing body".into())
12
        }
13
    } else {
14
        Err("missing content-type".into())
15
    }
16
}
17

18
// 传统方式 2：and_then 链（函数式但可读性差）
19
fn handle_old2(req: &Request) -> Result<String, String> {
20
    req.headers.get("content-type")
21
        .ok_or_else(|| "missing content-type".to_string())
22
        .and_then(|ct| {
23
            if ct != "application/json" {
24
                return Err(format!("unsupported: {}", ct));
25
            }
26
            req.body.as_ref()
27
                .ok_or_else(|| "missing body".to_string())
28
                .cloned()
29
        })
30
}

1
let mut v = vec![1, 2, 3];
2
let mut iter = v.iter_mut();
3

4
match iter.next() {
5
    Some(x) if *x > 1 => {
6
        // x 是 &mut i32
7
        *x += 10;  // ✅ arm 体中可变借用
8
    }
9
    _ => {}
10
}
11

12
// ❌ guard 中不能对可变引用做可变操作
13
// match iter.next() {
14
//     Some(x) if { *x += 1; *x > 2 } => {  // guard 中修改 x
15
//         // ...
16
//     }
17
//     _ => {}
18
// }

1
// ❌ let 中不能用 refutable pattern
2
// let Some(x) = option;  // 编译错误
3

4
// ✅ 方案 1：let-else
5
let Some(x) = option else {
6
    return;
7
};
8

9
// ✅ 方案 2：if let
10
if let Some(x) = option {
11
    // use x
12
}
13

14
// ✅ 方案 3：match
15
match option {
16
    Some(x) => { /* use x */ }
17
    None => { /* handle */ }
18
}

1
enum PaymentMethod {
2
    CreditCard {
3
        number: String,
4
        expiry: (u8, u16),  // (月, 年)
5
        cvv: u8,
6
    },
7
    BankTransfer {
8
        routing: String,
9
        account: String,
10
    },
11
    Crypto {
12
        wallet_address: String,
13
        network: CryptoNetwork,
14
    },
15
    GiftCard {
16
        code: String,
17
        remaining_balance: u64,
18
    },
19
}
20

21
enum CryptoNetwork {
22
    Bitcoin,
23
    Ethereum,
24
    Solana,
25
}
26

27
impl PaymentMethod {
28
    fn processing_fee(&self) -> u64 {
29
        match self {
30
            Self::CreditCard { .. } => 299,    // $2.99
31
            Self::BankTransfer { .. } => 0,     // 免费
32
            Self::Crypto { network, .. } => match network {
33
                CryptoNetwork::Bitcoin => 500,
34
                CryptoNetwork::Ethereum => 300,
35
                CryptoNetwork::Solana => 10,
36
            },
37
            Self::GiftCard { .. } => 0,
38
        }
39
    }
40

41
    fn is_instant(&self) -> bool {
42
        matches!(self, Self::Crypto { .. } | Self::GiftCard { .. })
43
    }
44
}

1
enum Expr {
2
    Literal(Literal),
3
    Binary { op: BinOp, left: Box<Expr>, right: Box<Expr> },
4
    Unary { op: UnaryOp, operand: Box<Expr> },
5
    Call { func: String, args: Vec<Expr> },
6
    If { cond: Box<Expr>, then: Box<Expr>, else_: Option<Box<Expr>> },
7
    Lambda { params: Vec<String>, body: Box<Expr> },
8
}
9

10
enum Literal {
11
    Int(i64),
12
    Float(f64),
13
    Bool(bool),
14
    Str(String),
15
}
16

17
enum BinOp { Add, Sub, Mul, Div, And, Or, Eq, Ne }
18
enum UnaryOp { Neg, Not }

1
fn free_variables(expr: &Expr) -> Vec<String> {
2
    match expr {
3
        Expr::Literal(_) => Vec::new(),
4
        Expr::Binary { left, right, .. } => {
5
            let mut vars = free_variables(left);
6
            vars.extend(free_variables(right));
7
            vars.dedup();
8
            vars
9
        }
10
        Expr::Unary { operand, .. } => free_variables(operand),
11
        Expr::Call { args, .. } => {
12
            let mut vars = Vec::new();
13
            for arg in args {
14
                vars.extend(free_variables(arg));
15
            }
16
            vars.dedup();
17
            vars
18
        }
19
        Expr::If { cond, then, else_ } => {
20
            let mut vars = free_variables(cond);
21
            vars.extend(free_variables(then));
22
            if let Some(e) = else_ {
23
                vars.extend(free_variables(e));
24
            }
25
            vars.dedup();
26
            vars
27
        }
28
        Expr::Lambda { params, body } => {
29
            let mut vars = free_variables(body);
30
            vars.retain(|v| !params.contains(v));
31
            vars
32
        }
33
    }
34
}

1
enum OrderState {
2
    Created { timestamp: u64 },
3
    Paid { timestamp: u64, method: PaymentMethod },
4
    Shipped { timestamp: u64, tracking: String },
5
    Delivered { timestamp: u64 },
6
    Cancelled { reason: String },
7
}
8

9
impl OrderState {
10
    fn can_cancel(&self) -> bool {
11
        matches!(self, Self::Created { .. } | Self::Paid { .. })
12
    }
13

14
    fn can_ship(&self) -> bool {
15
        matches!(self, Self::Paid { .. })
16
    }
17
}