为已定义结构的枚举编写 match 语句的正确方法是什么？

Question

我希望枚举的行为类似于我之前定义的结构的变体：

pub struct Element {
    symbol: String,
    atomic_number: u8,
    atomic_mass: f32,
}
pub struct Hydrogen {
    element: Element,
}
pub struct Helium {
    element: Element,
}
pub struct Lithium {
    element: Element,
}
pub enum ElementKind {
    HYDROGEN(Hydrogen),
    HELIUM(Helium),
    LITHIUM(Lithium,
}

impl Default for Hydrogen {
    fn default() -> Self {
        Hydrogen {
            element: Element {
                symbol: "H".to_string(),
                atomic_number: 1,
                atomic_mass: 1.008,
            },
        }
    }
}

impl Default for Helium {
    fn default() -> Self {
        Helium {
            element: Element {
                symbol: "He".to_string(),
                atomic_number: 2,
                atomic_mass: 4.003,
            },
        }
    }
}

impl Default for Lithium {
    fn default() -> Self {
        Lithium {
            element: Element {
                symbol: "Li".to_string(),
                atomic_number: 3,
                atomic_mass: 6.491,
            },
        }
    }
}

fn main() {
    let e = ElementKind::HYDROGEN;
    match e {
        // TODO
    }
}

编写match 语句以便始终打印出元素的symbol 的正确方法是什么？

Answer 1

当你写作时

struct Foo {
    foo: u32,
}

enum Bar {
    Foo,
}

Foo 结构和Bar::Foo 变体之间绝对没有关系。他们只是碰巧有相同的名字。 （另见Is there a way to use existing structs as enum variants?）。

解决这个问题的常用方法是在变体中添加一个字段：

enum Bar {
    // The first Foo is the variant name, the second Foo a field of type Foo
    Foo(Foo),
}

或在枚举中内联结构（即使用struct 变体）：

enum Bar {
    Foo {
        foo: u32,
    }
}

但是，在您的情况下，我相信您不需要为每个元素创建一个结构，只需执行以下操作：

#[derive(Debug)]
pub struct Element {
    symbol: String,
    atomic_number: u8,
    atomic_mass: f32,
}

pub enum ElementKind {
    Hydrogen,
    Helium,
    Lithium,
}

impl From<ElementKind> for Element {
    fn from(e: ElementKind) -> Element {
        use ElementKind::*;

        match e {
            Hydrogen => Element {
                symbol: "H".to_string(),
                atomic_number: 1,
                atomic_mass: 1.008,
            },
            Helium => Element {
                symbol: "He".to_string(),
                atomic_number: 2,
                atomic_mass: 4.003,
            },
            Lithium => Element {
                symbol: "Li".to_string(),
                atomic_number: 3,
                atomic_mass: 6.491,
            },
        }
    }
}

fn main() {
    let e = ElementKind::Hydrogen;
    println!("{:#?}", Element::from(e));
}

(Permalink to the playground)

确实，使用您的解决方案，ElementKind 的每个实例都将包含冗余信息：变体本身（足以识别元素）及其数据（也足以识别元素）。