Rust中如何向函数传递带参数的枚举（用_作占位符）

你的核心问题是原方法需要传入完整的Kind枚举实例（包括参数值）才能匹配，但你只想校验变体类型，同时提取变体中的参数。下面是几种可行的实现方式：

1. 为每个变体编写专用方法（最直观简洁） #

针对枚举的每个变体单独实现方法，直接返回对应参数或成功标记，调用时非常简洁：

#[derive(PartialEq, Eq)]
enum Kind {
    Kind1,
    Kind2(String),
}

struct S {
    kinds: std::vec::IntoIter<Kind>,
}

impl S {
    // 匹配Kind1，无参数返回()
    fn next_kind1(&mut self) -> Result<(), &str> {
        match self.kinds.next() {
            Some(Kind::Kind1) => Ok(()),
            _ => Err("expected Kind1"),
        }
    }

    // 匹配Kind2，直接返回内部的String
    fn next_kind2(&mut self) -> Result<String, &str> {
        match self.kinds.next() {
            Some(Kind::Kind2(s)) => Ok(s),
            _ => Err("expected Kind2"),
        }
    }
}

fn main() {
    let mut s = S {
        kinds: vec![Kind::Kind1, Kind::Kind2(String::from("2"))].into_iter(),
    };
    // 调用Kind1的匹配方法
    s.next_kind1().unwrap();

    // 调用Kind2的匹配方法，直接获取内部字符串
    let _val = s.next_kind2().unwrap();
}

这种方式类型安全，调用代码清晰，完全符合你想要的简洁调用体验。如果枚举变体较多，可以用宏自动生成这些方法，避免重复代码。

2. 通用闭包匹配方法（更灵活） #

如果需要更通用的实现，可以让方法接收一个闭包，由闭包负责匹配变体并提取值：

impl S {
    fn next_match<T, F>(&mut self, matcher: F) -> Result<T, &str>
    where
        F: FnOnce(Kind) -> Option<T>,
    {
        match self.kinds.next() {
            Some(kind) => matcher(kind).ok_or("not expected variant"),
            None => Err("no more elements left"),
        }
    }
}

// 调用示例
let _val = s.next_match(|kind| match kind {
    Kind::Kind2(s) => Some(s),
    _ => None,
}).unwrap();

这种方式不需要为每个变体写单独方法，适合需要临时自定义匹配逻辑的场景。

3. 变体类型枚举方案 #

定义一个只区分变体类型的枚举，用于校验类型，然后再解构原枚举提取参数：

// 定义仅标记变体类型的枚举
enum KindVariant {
    Kind1,
    Kind2,
}

// 实现从Kind到KindVariant的转换
impl From<Kind> for KindVariant {
    fn from(kind: Kind) -> Self {
        match kind {
            Kind::Kind1 => KindVariant::Kind1,
            Kind::Kind2(_) => KindVariant::Kind2,
        }
    }
}

impl S {
    fn next_expected_variant(&mut self, expected: KindVariant) -> Result<Kind, &str> {
        match self.kinds.next() {
            Some(kind) if KindVariant::from(kind) == expected => Ok(kind),
            _ => Err("unexpected variant"),
        }
    }
}

// 调用示例
let _val = match s.next_expected_variant(KindVariant::Kind2) {
    Ok(Kind::Kind2(s)) => s,
    _ => panic!("error"),
};

这种方式兼顾了类型校验和参数提取，但调用时需要多一步解构，适合需要统一处理多种变体的场景。

内容的提问来源于stack exchange，提问作者Alan Alves de Oliveira