Rust中选择性转移内部值实现枚举转换的优化方案

问题背景 #

定义两个枚举：

enum E1 {
  A { val: SomeValue1 },
  B(SomeValue2),
  C(SomeValue3),
}

enum E2 {
  A,
  B(SomeValue2),
  C(SomeValue3),
  D,
  E
}

其中SomeValueX未实现Copy或Clone trait。需要实现接收E1输入的代码，完成两个操作：

1. 对枚举内部值执行操作，E1::A(val)需获取val所有权；
2. 将E1转换为E2类型。

当前实现：

fn example(input: E1) -> E2 {
  match input {
    E1::A(val) => { do_something_with_a(val); E2::A },
    E1::B(val) => { do_something_with_b(&val); E2::B(val) },
    E1::C(val) => { do_something_with_c(&val); E2::C(val) },
  }
}

尝试拆分两个操作到独立函数时遇到困境：

• 转换函数消费E1会导致E1::A(val)被提前消耗，无法用于操作；
• 转换函数接收E1引用则无法转移B/C变体的val所有权来构建E2。

以下是几种可行的优化方案：

方案一：新增中间枚举拆分逻辑 #

定义一个代表“处理后状态”的中间枚举，先完成操作再做转换：

// 定义处理后的中间枚举
enum ProcessedE1 {
    A,
    B(SomeValue2),
    C(SomeValue3),
}

// 独立操作函数：消费原始E1，执行操作后返回中间枚举
fn process_e1(input: E1) -> ProcessedE1 {
    match input {
        E1::A(val) => {
            do_something_with_a(val);
            ProcessedE1::A
        }
        E1::B(val) => {
            do_something_with_b(&val);
            ProcessedE1::B(val)
        }
        E1::C(val) => {
            do_something_with_c(&val);
            ProcessedE1::C(val)
        }
    }
}

// 独立转换函数：消费中间枚举，转为E2
fn processed_e1_to_e2(input: ProcessedE1) -> E2 {
    match input {
        ProcessedE1::A => E2::A,
        ProcessedE1::B(val) => E2::B(val),
        ProcessedE1::C(val) => E2::C(val),
    }
}

// 调用示例
fn example(input: E1) -> E2 {
    let processed = process_e1(input);
    processed_e1_to_e2(processed)
}

该方案逻辑清晰，完全拆分操作与转换，无hack实现。

方案二：修改原枚举标记处理状态 #

直接扩展原E1枚举，新增标记已处理的变体，避免额外定义中间类型：

// 修改原E1，新增已处理的A变体
enum E1 {
    A { val: SomeValue1 },
    AProcessed,
    B(SomeValue2),
    C(SomeValue3),
}

// 预处理函数：消费E1，执行操作后返回标记处理状态的E1
fn process_e1(mut input: E1) -> E1 {
    match input {
        E1::A { val } => {
            do_something_with_a(val);
            E1::AProcessed
        }
        E1::B(ref val) => {
            do_something_with_b(val);
            input
        }
        E1::C(ref val) => {
            do_something_with_c(val);
            input
        }
        _ => input,
    }
}

// 转换函数：消费处理后的E1，转为E2
fn e1_to_e2(input: E1) -> E2 {
    match input {
        E1::AProcessed => E2::A,
        E1::B(val) => E2::B(val),
        E1::C(val) => E2::C(val),
        _ => unreachable!("预处理后的E1不存在未处理的A变体"),
    }
}

// 调用示例
fn example(input: E1) -> E2 {
    let processed = process_e1(input);
    e1_to_e2(processed)
}

适合不想新增太多类型的场景，通过变体标记明确状态。

方案三：用宏封装拆分逻辑 #

如果不想修改枚举结构，可通过宏封装匹配逻辑，同时将操作逻辑拆为独立函数：

// 独立的操作函数
fn handle_a(val: SomeValue1) {
    do_something_with_a(val);
}

fn handle_b(val: &SomeValue2) {
    do_something_with_b(val);
}

fn handle_c(val: &SomeValue3) {
    do_something_with_c(val);
}

// 宏封装操作+转换逻辑
macro_rules! process_and_convert {
    ($input:expr) => {{
        match $input {
            E1::A(val) => {
                handle_a(val);
                E2::A
            }
            E1::B(val) => {
                handle_b(&val);
                E2::B(val)
            }
            E1::C(val) => {
                handle_c(&val);
                E2::C(val)
            }
        }
    }};
}

// 调用示例
fn example(input: E1) -> E2 {
    process_and_convert!(input)
}

该方案无需修改枚举，通过宏减少重复代码，同时保持操作逻辑的独立性。

内容的提问来源于stack exchange，提问作者Anton