面试题：Rust模式匹配灵活性拓展之专家题

Question

考虑一个高度动态的场景，有一个特质`TraitA`，多个结构体实现了该特质。同时有一个`enum`类型`enum DynamicValue { Int(i32), Float(f64), Str(String), Custom(Box<dyn TraitA>) }`。编写一个通用的函数，利用Rust模式匹配的灵活性拓展，对`DynamicValue`中的各种类型进行合理的处理，特别是对于`Custom`变体，要根据实现`TraitA`的不同结构体进行不同的操作。并且要求函数尽可能简洁和高效，同时兼顾代码的可读性。

Answer 1

trait TraitA {
    fn do_something(&self);
}

struct StructA;
impl TraitA for StructA {
    fn do_something(&self) {
        println!("StructA does something");
    }
}

struct StructB;
impl TraitA for StructB {
    fn do_something(&self) {
        println!("StructB does something");
    }
}

enum DynamicValue {
    Int(i32),
    Float(f64),
    Str(String),
    Custom(Box<dyn TraitA>),
}

fn handle_dynamic_value(value: DynamicValue) {
    match value {
        DynamicValue::Int(i) => println!("Handling Int: {}", i),
        DynamicValue::Float(f) => println!("Handling Float: {}", f),
        DynamicValue::Str(s) => println!("Handling Str: {}", s),
        DynamicValue::Custom(custom) => {
            if let Some(struct_a) = custom.downcast_ref::<StructA>() {
                struct_a.do_something();
            } else if let Some(struct_b) = custom.downcast_ref::<StructB>() {
                struct_b.do_something();
            } else {
                println!("Unknown type implementing TraitA");
            }
        }
    }
}

你可以使用如下方式调用这个函数：

fn main() {
    let int_value = DynamicValue::Int(10);
    let float_value = DynamicValue::Float(3.14);
    let str_value = DynamicValue::Str("Hello".to_string());
    let struct_a_value = DynamicValue::Custom(Box::new(StructA));
    let struct_b_value = DynamicValue::Custom(Box::new(StructB));

    handle_dynamic_value(int_value);
    handle_dynamic_value(float_value);
    handle_dynamic_value(str_value);
    handle_dynamic_value(struct_a_value);
    handle_dynamic_value(struct_b_value);
}