Rust多返回类型枚举解包内部类型并调用方法的问题

我编写了一个返回枚举类型的Rust函数（因存在多种可能的返回类型而使用枚举），希望调用枚举变体对应结构体上的print_type方法，但直接调用myTypeObject.print_type()出现报错。

相关代码 #

fn main() {
    let myTypeObject = get_a_type(1);
    myTypeObject.print_type();
}

struct TypeOne {
    typename: String,
    typeid: u8,
}

struct TypeTwo {
    typename: String,
    typeid: u8,
}

trait TraitOneTwo {
    fn new(name: String) -> Self;
    fn print_type(self);
}

impl TraitOneTwo for TypeOne {
    fn new(name: String) -> Self {
        Self {
            typename: name,
            typeid: 1,
        }
    }
    fn print_type(self) {
        println!("My type is: {}", self.typename);
    }
}

impl TraitOneTwo for TypeTwo {
    fn new(name: String) -> Self {
        Self {
            typename: name,
            typeid: 2,
        }
    }
    fn print_type(self) {
        println!("My type is: {}", self.typename);
    }
}

enum Types {
    T1(TypeOne),
    T2(TypeTwo),
}

fn get_a_type(desired_type: u8) -> Types {
    if let 1 = desired_type {
        return Types::T1(TypeOne::new(String::from("Foo")));
    } else {
        return Types::T2(TypeTwo::new(String::from("Bar")));
    }
}

报错信息 #

error[E0599]: no method named `print_type` found for enum `Types` in the current scope
  --> src/main.rs:3:18
   |
3  |     myTypeObject.print_type();
   |                  ^^^^^^^^^^ method not found in `Types`
...
45 | enum Types {
   | ---------- method `print_type` not found for this
   |
   = help: items from traits can only be used if the trait is implemented and in scope
note: `TraitOneTwo` defines an item `print_type`, perhaps you need to implement it
  --> src/main.rs:16:1
   |
16 | trait TraitOneTwo {
   | ^^^^^^^^^^^^^^^^^

我尝试将类型转换为具体结构体，代码如下：

fn main() {
    let myTypeObject: TypeOne = get_a_type(1).try_into().unwrap();
    myTypeObject.print_type();
}

但仍出现报错：

error[E0277]: the trait bound `TypeOne: From<Types>` is not satisfied
 --> src/main.rs:2:47
  |
2 |     let myTypeObject: TypeOne = get_a_type(1).try_into().unwrap();
  |                                               ^^^^^^^^ the trait `From<Types>` is not implemented for `TypeOne`
  |
  = note: required because of the requirements on the impl of `Into<TypeOne>` for `Types`
  = note: required because of the requirements on the impl of `TryFrom<Types>` for `TypeOne`
  = note: required because of the requirements on the impl of `TryInto<TypeOne>` for `Types`

请问如何正确调用print_type()函数？

方法一：为枚举Types实现TraitOneTwo trait #

既然两个结构体都实现了TraitOneTwo，可以直接为枚举Types实现该trait，在方法里匹配变体并调用对应结构体的逻辑：

impl TraitOneTwo for Types {
    fn new(name: String) -> Self {
        // 可根据需求调整默认变体，比如按名称判断或固定返回T1
        Types::T1(TypeOne::new(name))
    }

    fn print_type(self) {
        match self {
            Types::T1(t1) => t1.print_type(),
            Types::T2(t2) => t2.print_type(),
        }
    }
}

修改后原main函数的myTypeObject.print_type()即可正常运行。

方法二：在main中匹配枚举变体调用方法 #

如果不想为枚举实现trait，可直接在main里通过match遍历所有变体，分别调用对应方法：

fn main() {
    let myTypeObject = get_a_type(1);
    match myTypeObject {
        Types::T1(t1) => t1.print_type(),
        Types::T2(t2) => t2.print_type(),
    }
}

这种方式无需额外实现，适合变体数量较少的场景。

方法三：实现TryFrom trait完成类型转换 #

若坚持要将枚举转为具体结构体，可为TypeOne和TypeTwo实现TryFrom<Types> trait：

impl TryFrom<Types> for TypeOne {
    type Error = &'static str;

    fn try_from(value: Types) -> Result<Self, Self::Error> {
        match value {
            Types::T1(t1) => Ok(t1),
            _ => Err("Not a TypeOne"),
        }
    }
}

impl TryFrom<Types> for TypeTwo {
    type Error = &'static str;

    fn try_from(value: Types) -> Result<Self, Self::Error> {
        match value {
            Types::T2(t2) => Ok(t2),
            _ => Err("Not a TypeTwo"),
        }
    }
}

之后你的main代码即可正常运行，但注意unwrap()在转换失败时会触发panic，实际项目建议用match或if let处理错误分支。

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