[08_enums/enum2.rs] Messages array vs individual Message variables

[mihemihe]

08_enums/enum2.rs code defines an array of messages:

    let messages = [
        Message::Resize {
            width: 10,
            height: 30,
        },
        Message::Move(Point { x: 10, y: 15 }),
        Message::Echo(String::from("hello world")),
        Message::ChangeColor(200, 255, 255),
        Message::Quit,
    ];

For newcomers, this syntax can be confusing,especially without type inlay hints.

It looks very similar to a single struct initialization rather than an array of multiple enum variants. The messages variable can easily be mistaken for one instance of a Message instead of a list of different ones.

If someone is learning Rust enum syntax for the first time, the messages array initialization resembles a struct initialization (which users have it fresh in memory because they are the preceding exercises).

I think the exercise will benefit from having some individual definitions first, and then the messages array.

Something like:

   let move_point = Message::Move(Point { x: 100, y: 50 });
   let echo = Message::Echo(String::from("Comms up"));

   let messages = [
        Message::Resize {
            width: 10,
            height: 30,
        },
        Message::Move(Point { x: 10, y: 15 }),
        Message::Echo(String::from("hello world")),
        Message::ChangeColor(200, 255, 255),
        Message::Quit,
    ];

[jvcByte]

Hello @mihemihe!

Your point about the potential confusion is valid but:

1. The exercise is working as designed: enum2 is meant to teach "all the different types of possible implementations for enums" using Classic C Struct syntax, Tuple Struct syntax, and Unit Struct syntax.

2. The confusion is part of learning: The exercise forces learners to understand that enums can hold different data structures. The slight confusion might actually be pedagogically valuable.

3. Context is provided: Learners have access to README documentation and the enum definition itself clearly shows the variants.

4. Type inference is a Rust feature: Learning to read and understand type-inferred code is an important Rust skill. Over-explaining might delay developing this skill.