type-conversion - 在 Rust 中创建类型之间的自定义转换的标准方法是什么？

Question

如果我定义了一些枚举并想创建一个从字符串到该类型的解析器，有没有比仅仅更好的东西：

impl TheType {
    fn from_str(s: &str) -> TheType { 
        // ...
    }
}

Answer 1

从字符串转换/解析文本的正确方法是实现FromStr特征。对于问题中的示例，它看起来像这样：

use std::str::FromStr;

enum Failure {
    ReasonOne,
    ReasonTwo,
}

impl FromStr for TheType {
    type Err = Failure;

    fn from_str(s: &str) -> Result<TheType, Self::Err> { 
        unimplemented!()
    }
}

Answer 2

对于不能失败的通用转换，您应该实现std::convert::From特征：

use std::convert::From;

#[derive(PartialEq, Eq, Debug)]
enum MyEnum {
    One,
    Two,
    Many(i64),
}

impl From<i64> for MyEnum {
    fn from(val: i64) -> Self {
        match val {
            1 => MyEnum::One,
            2 => MyEnum::Two,
            _ => MyEnum::Many(val),
        }
    }
}

fn main() {
    assert_eq!(MyEnum::from(1), MyEnum::One);
    assert_eq!(MyEnum::from(2), MyEnum::Two);
    assert_eq!(MyEnum::from(3), MyEnum::Many(3));
}

方便的是，实现From也自动实现Into：

let one: MyEnum = 1.into(); assert_eq!(one, MyEnum::One);
let two: MyEnum = 2.into(); assert_eq!(two, MyEnum::Two);
let many: MyEnum = 3.into(); assert_eq!(many, MyEnum::Many(3));

对于可能失败的转换，您应该实施std::convert::TryFrom。它仅在 Rust 1.34 及更高版本中可用，在这些版本之前，您可以使用convcrate中的实现。