Structs & Enums Highlights Summary

Every highlight bullet from the 11 pages in this section, gathered on one page and grouped by the page it came from.

Modeling Data with Structs and Enums

• Structs are product types: a value made of every field, all at once
• Enums are sum types: a value that is exactly one of a fixed set of variants
• Exhaustive match turns 'we forgot a case' into a compile error, not a bug report
• Making illegal states unrepresentable means the type itself rules out invalid combinations

Structs Basics

• Named structs group related fields with clear names
• Tuple structs wrap a value with a new type
• Update syntax .. reuses fields from an existing instance

Methods & Associated Functions

• Methods take self, &self, or &mut self as the first parameter
• Associated functions (no self) include common constructors like new
• Multiple impl blocks per type are allowed

Enums

• Each variant can carry zero or more typed payloads
• Enums express closed sets of possibilities the compiler tracks
• Option and Result are enums used everywhere in Rust

Pattern Matching with match

• match compares a value against patterns and runs the first matching arm
• The compiler enforces exhaustiveness for match expressions
• Guards like if n < 0 refine a match arm's condition
• match can bind variables from enum variant payloads
• Missing enum variants after changes cause compile-time errors
• match arms must return the same type when used as an expression

if let, let else & while let

• Use if let, let else, and while let for single pattern matches
• let else provides early return if a pattern does not match
• while let loops as long as a pattern continues to match
• let else's else block must diverge with return, break, or panic
• Avoid chaining many if let statements; use match instead
• while let is ideal for consuming iterators of Option or Result

Option & Result as Enums

• Option models presence or absence of a value
• Result models success or recoverable failure
• Use Option for legitimately missing data, not errors
• Avoid unwrap in library code; return Result or Option instead
• The ? operator propagates Result errors in functions returning Result
• Collect Vec<Result> short-circuits on the first error

Destructuring

• Destructuring unpacks structs, tuples, enums, and slices into bindings
• Use destructuring to extract fields, match nested data, or ignore parts
• let Point { x, y } = p; destructures a struct into variables
• match s { Shape::Circle { radius } => ... } destructures enum variants
• Ignoring fields uses .. in structs or _ in tuples
• Destructuring can move fields; use &val or ref to borrow

Deriving Traits

• Derive auto-implements standard traits for structs and enums
• Use derive for Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default
• Derived Ord on enums requires discriminant ordering
• Cannot derive Eq or Ord on floats; use manual impl
• Derived Hash changes if field order changes
• Manual impl is needed for custom logic or traits like Display

Enums for State Machines

• Model each state as an enum variant with only valid data
• Use enums for protocol handlers, UI flows, and parsers
• Consume self to transition state in a typestate pattern
• Return Err for invalid state transitions
• Avoid boolean flags that can create invalid states

Structs & Enums Best Practices

• Prefer small focused structs over god objects
• Make struct fields private; expose constructors and accessors
• Replace boolean pairs with enums when states multiply
• Transition enums via methods consuming self
• Separate wire DTOs from domain types when shapes differ

383k393a3c3q3e393a3o1r3e3k3x383c3e3k1u211w3x1v1t1v1z1t20