Rust Structs & Enums Practice: Custom Types, Option & Result

Struct fields are private by default. Making the struct pub only makes the type visible — each field needs its own pub:

mod user {
    pub struct User {
        name: String,  // private!
    }
}

// WRONG: can see the type, but not the field
// let u = user::User { name: String::from("Ada") };
// error[E0616]: field `name` of struct `User` is private

Two fixes, depending on your design:

// Option 1: make fields pub (simple data types)
mod user_pub {
    pub struct User {
        pub name: String,
    }
}

// Option 2: keep fields private, expose a constructor (preserves invariants)
mod user_new {
    pub struct User {
        name: String,
    }
    impl User {
        pub fn new(name: impl Into<String>) -> Self {
            Self { name: name.into() }
        }
        pub fn name(&self) -> &str { &self.name }
    }
}

Prefer Option 2 when the struct has invariants to enforce (e.g., validated email, non-empty name). For complex construction logic, the Builder pattern provides a fluent API that validates fields step by step.

Your match doesn't cover every enum variant:

enum Status { Active, Inactive, Pending }

// WRONG: missing Pending
// match status {
//     Status::Active => "on",
//     Status::Inactive => "off",
//     // error[E0004]: non-exhaustive patterns: `Pending` not covered
// }

// RIGHT: handle all variants
match status {
    Status::Active => "on",
    Status::Inactive => "off",
    Status::Pending => "waiting",
}

// Or use _ as a catch-all (careful: won't warn on new variants)
match status {
    Status::Active => "on",
    _ => "not active",
}

The compiler cannot infer the type of None without context:

// WRONG: what type is this Option?
// let x = None;  // error[E0282]: type annotations needed

// RIGHT: annotate the binding
let x: Option<i32> = None;

// RIGHT: turbofish
let x = Option::<i32>::None;

• Struct: all fields exist at once (AND). A user always has a name AND an age.
• Enum: one of several variants (OR). A message is Quit OR Write OR Move.

If a value can be in multiple states, use an enum. If it always has the same set of fields, use a struct.

struct User {
    name: String,
    email: String,
    active: bool,
}

impl User {
    // Constructor (associated function — no self)
    fn new(name: String, email: String) -> Self {
        Self { name, email, active: true }  // field init shorthand
    }

    // Method (takes &self)
    fn is_active(&self) -> bool {
        self.active
    }

    // Mutable method (takes &mut self)
    fn deactivate(&mut self) {
        self.active = false;
    }
}

Field Init Shorthand

When a variable has the same name as a struct field, you can omit the field name:

let name = String::from("Ada");
let email = String::from("ada@example.com");

// Long form
let u = User { name: name, email: email, active: true };

// Shorthand — same result
let u = User { name, email, active: true };

Struct Update Syntax

Create a new struct from an existing one, overriding specific fields:

let user1 = User::new("Ada".into(), "ada@example.com".into());
let user2 = User { email: String::from("new@example.com"), ..user1 };
// user1.name was MOVED into user2 (String is not Copy)
// user1 can no longer be used as a whole

The ..user1 syntax moves non-Copy fields. After the update, the original struct cannot be used if any moved field was consumed. Tuple structs that wrap a single type are known as newtypes -- a powerful pattern for adding type safety. For a deep dive, read how Rust newtypes catch unit bugs at compile time. When you need to construct different variants of a type at runtime, the Factory pattern formalizes this approach.

enum Message {
    Quit,                       // unit variant (no data)
    Write(String),              // tuple variant (unnamed data)
    Move { x: i32, y: i32 },   // struct variant (named fields)
}

let msg = Message::Write(String::from("hi"));

match msg {
    Message::Quit => println!("quit"),
    Message::Write(text) => println!("{text}"),
    Message::Move { x, y } => println!("move to ({x}, {y})"),
}

You must pattern-match to access data inside enum variants. Trying to access it directly won't compile. The pattern matching guide covers all the ways to destructure enum data. For a quick-reference of enum syntax, see the enums cheat sheet.

// Option<T>: Some(T) or None
let value: Option<i32> = Some(5);
let empty: Option<i32> = None;

// Result<T, E>: Ok(T) or Err(E)
let ok: Result<i32, String> = Ok(1);
let err: Result<i32, String> = Err(String::from("fail"));

Methods You Will Use Daily

• The Rust Book: Structs — definitions, methods, update syntax
• The Rust Book: Enums — variants, Option, match
• std::option::Option — full combinator API
• std::result::Result — map, map_err, and_then