Introduction to Enums in Rust

Enums (enumerations) in Rust are a powerful way to define a type that can be one of several variants. Unlike enums in many other languages, Rust's enums can contain data, making them a form of algebraic data types (ADTs). They are fundamental to Rust's type system and are used extensively for error handling, state machines, and domain modeling.

Key Concepts

• Type Safety: Enums ensure that only valid variants can be used
• Pattern Matching: Enums work seamlessly with match expressions
• Data Carrier: Each variant can hold different types and amounts of data
• Exhaustiveness: The compiler ensures all variants are handled
• Memory Efficiency: Enums use only as much memory as the largest variant

1. Basic Enum Syntax

Simple Enums

// Basic enum without data enum Direction { North, South, East, West, } enum DayOfWeek { Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday, } enum HttpStatus { Ok, NotFound, InternalServerError, } fn main() { // Creating enum instances let direction = Direction::North; let day = DayOfWeek::Friday; let status = HttpStatus::Ok; // Using match with enums match direction { Direction::North => println!("Going North!"), Direction::South => println!("Going South!"), Direction::East => println!("Going East!"), Direction::West => println!("Going West!"), } // Enums can be compared with pattern matching match day { DayOfWeek::Saturday | DayOfWeek::Sunday => println!("Weekend!"), _ => println!("Weekday :("), } }

Enums with Discriminants

// Enums can have explicit integer values (like C enums) enum Color { Red = 0xff0000, Green = 0x00ff00, Blue = 0x0000ff, Yellow = 0xffff00, } enum HttpStatusCode { Ok = 200, Created = 201, Accepted = 202, BadRequest = 400, NotFound = 404, InternalServerError = 500, } fn main() { // Accessing discriminant values println!("Red value: {}", Color::Red as i32); println!("Green value: {:x}", Color::Green as i32); println!("Blue value: {:06x}", Color::Blue as i32); // Converting from integer to enum (with safety) fn status_from_code(code: u16) -> Option<HttpStatusCode> { match code { 200 => Some(HttpStatusCode::Ok), 201 => Some(HttpStatusCode::Created), 202 => Some(HttpStatusCode::Accepted), 400 => Some(HttpStatusCode::BadRequest), 404 => Some(HttpStatusCode::NotFound), 500 => Some(HttpStatusCode::InternalServerError), _ => None, } } if let Some(status) = status_from_code(200) { println!("Status code 200 means {:?}", status); } }

2. Enums with Data

Different Types of Data in Variants

// Each variant can hold different data enum Message { Quit, // No data Move { x: i32, y: i32 }, // Anonymous struct Write(String), // Single type ChangeColor(i32, i32, i32), // Tuple Echo(String), // Multiple variants can have same type Resize { width: u32, height: u32 }, } // Enum with numeric values enum Shape { Circle(f64), // radius Rectangle { width: f64, height: f64 }, Triangle(f64, f64, f64), // sides } // Enum with different data types enum WebEvent { PageLoad, KeyPress(char), Click { x: i64, y: i64 }, } fn main() { // Creating instances with data let msg1 = Message::Quit; let msg2 = Message::Move { x: 10, y: 20 }; let msg3 = Message::Write(String::from("Hello")); let msg4 = Message::ChangeColor(255, 0, 0); // Processing different variants process_message(msg1); process_message(msg2); process_message(msg3); process_message(msg4); // Working with shapes let circle = Shape::Circle(5.0); let rect = Shape::Rectangle { width: 10.0, height: 20.0 }; let triangle = Shape::Triangle(3.0, 4.0, 5.0); println!("Circle area: {}", area(circle)); println!("Rectangle area: {}", area(rect)); println!("Triangle area: {}", area(triangle)); } fn process_message(msg: Message) { match msg { Message::Quit => println!("Quitting"), Message::Move { x, y } => println!("Moving to ({}, {})", x, y), Message::Write(text) => println!("Writing: {}", text), Message::ChangeColor(r, g, b) => println!("Changing color to RGB({},{},{})", r, g, b), Message::Echo(s) => println!("Echo: {}", s), Message::Resize { width, height } => println!("Resizing to {}x{}", width, height), } } fn area(shape: Shape) -> f64 { match shape { Shape::Circle(radius) => std::f64::consts::PI * radius * radius, Shape::Rectangle { width, height } => width * height, Shape::Triangle(a, b, c) => { let s = (a + b + c) / 2.0; (s * (s - a) * (s - b) * (s - c)).sqrt() } } }

Nested Enums

// Enums can contain other enums #[derive(Debug)] enum NetworkDevice { Router, Switch, Firewall, } #[derive(Debug)] enum Protocol { TCP, UDP, ICMP, } #[derive(Debug)] enum Packet { Incoming { device: NetworkDevice, protocol: Protocol, data: Vec<u8>, }, Outgoing { protocol: Protocol, destination: String, data: Vec<u8>, }, Error(String), } // Enums in collections enum Value { Integer(i32), Float(f64), Text(String), Boolean(bool), List(Vec<Value>), Dictionary(Vec<(String, Value)>), } fn main() { let packet = Packet::Incoming { device: NetworkDevice::Router, protocol: Protocol::TCP, data: vec![0x01, 0x02, 0x03], }; println!("Packet: {:?}", packet); // Complex nested enum let config = Value::Dictionary(vec![ ("name".to_string(), Value::Text("server".to_string())), ("port".to_string(), Value::Integer(8080)), ("enabled".to_string(), Value::Boolean(true)), ("tags".to_string(), Value::List(vec![ Value::Text("production".to_string()), Value::Text("critical".to_string()), ])), ]); // Process the nested structure if let Value::Dictionary(entries) = config { for (key, value) in entries { print!("{}: ", key); match value { Value::Integer(i) => println!("{}", i), Value::Float(f) => println!("{}", f), Value::Text(s) => println!("{}", s), Value::Boolean(b) => println!("{}", b), Value::List(l) => println!("{:?}", l), Value::Dictionary(_) => println!("nested dict"), } } } }

3. The Option Enum

Basic Option Usage

fn main() { // Option represents a value that may or may not exist let some_number: Option<i32> = Some(42); let some_string: Option<String> = Some(String::from("hello")); let absent_number: Option<i32> = None; // Using Option safely fn divide(numerator: f64, denominator: f64) -> Option<f64> { if denominator == 0.0 { None } else { Some(numerator / denominator) } } let result = divide(10.0, 2.0); let invalid = divide(10.0, 0.0); // Pattern matching with Option match result { Some(value) => println!("Result: {}", value), None => println!("Division by zero!"), } // if let for single pattern if let Some(value) = result { println!("Got value: {}", value); } // Option combinators let number = Some(5); // map - transform the value if it exists let doubled = number.map(|x| x * 2); println!("Doubled: {:?}", doubled); // and_then - chain operations that return Option let result = number .and_then(|x| if x > 0 { Some(x) } else { None }) .map(|x| x * 3); println!("Chained: {:?}", result); // unwrap_or - provide default let value = absent_number.unwrap_or(0); println!("Default value: {}", value); // unwrap_or_else - compute default lazily let value = absent_number.unwrap_or_else(|| { println!("Computing default..."); 42 }); println!("Computed value: {}", value); }

Advanced Option Patterns

fn main() { // Option with collections let numbers = vec![1, 2, 3, 4, 5]; // Safe indexing let first = numbers.get(0); // Some(&1) let tenth = numbers.get(10); // None // Option in filtering let even_numbers: Vec<_> = numbers .iter() .filter_map(|&x| if x % 2 == 0 { Some(x) } else { None }) .collect(); println!("Even numbers: {:?}", even_numbers); // Option with structs struct User { name: String, age: Option<u32>, // Age might be unknown } let users = vec![ User { name: "Alice".to_string(), age: Some(30) }, User { name: "Bob".to_string(), age: None }, User { name: "Charlie".to_string(), age: Some(25) }, ]; // Find first user with known age > 25 let result = users.iter() .find(|user| user.age.map_or(false, |age| age > 25)); if let Some(user) = result { println!("Found user: {}", user.name); } // Chaining Option operations fn process_user_age(user: &User) -> Option<String> { user.age .filter(|&age| age >= 18) .map(|age| format!("Adult: {} years old", age)) } for user in &users { if let Some(message) = process_user_age(user) { println!("{}: {}", user.name, message); } } // Option with try operator (?) in functions fn get_first_even(numbers: &[i32]) -> Option<i32> { let first = numbers.get(0)?; // Returns None if numbers is empty if first % 2 == 0 { Some(*first) } else { numbers.get(1).copied() } } println!("First even in [1,3,5]: {:?}", get_first_even(&[1,3,5])); println!("First even in [2,4,6]: {:?}", get_first_even(&[2,4,6])); }

4. The Result Enum

Basic Result Usage

use std::fs::File; use std::io::Read; #[derive(Debug)] enum MathError { DivisionByZero, NegativeSquareRoot, Overflow, } fn divide(a: f64, b: f64) -> Result<f64, String> { if b == 0.0 { Err(String::from("Division by zero")) } else { Ok(a / b) } } fn square_root(x: f64) -> Result<f64, &'static str> { if x < 0.0 { Err("Cannot take square root of negative number") } else { Ok(x.sqrt()) } } fn main() { // Basic Result handling let result1 = divide(10.0, 2.0); let result2 = divide(10.0, 0.0); match result1 { Ok(value) => println!("Result: {}", value), Err(e) => println!("Error: {}", e), } match result2 { Ok(value) => println!("Result: {}", value), Err(e) => println!("Error: {}", e), } // Result combinators let number = "42".parse::<i32>(); // map - transform Ok value let doubled = number.map(|x| x * 2); println!("Doubled: {:?}", doubled); // map_err - transform error let mapped_error = number.map_err(|e| format!("Parse error: {}", e)); // and_then - chain operations let result = number .and_then(|x| if x > 0 { Ok(x) } else { Err("negative") }) .map(|x| x * 2); println!("Chained result: {:?}", result); // unwrap_or - provide default for Ok let value = number.unwrap_or(0); println!("Value or default: {}", value); // unwrap_or_else - compute default lazily let value = number.unwrap_or_else(|_| { println!("Using fallback value"); 42 }); println!("Computed value: {}", value); }

Advanced Result Patterns

use std::num::ParseIntError; use std::fs; #[derive(Debug)] enum AppError { Io(std::io::Error), Parse(ParseIntError), Validation(String), } impl From<std::io::Error> for AppError { fn from(error: std::io::Error) -> Self { AppError::Io(error) } } impl From<ParseIntError> for AppError { fn from(error: ParseIntError) -> Self { AppError::Parse(error) } } fn read_number_from_file(path: &str) -> Result<i32, AppError> { // The ? operator automatically converts errors using From let content = fs::read_to_string(path)?; let number = content.trim().parse::<i32>()?; if number < 0 { return Err(AppError::Validation("Number must be positive".to_string())); } Ok(number) } fn main() { // Collecting Results into collections let strings = vec!["1", "2", "abc", "3", "def"]; // Collect into Result<Vec<i32>, ParseIntError> let numbers: Result<Vec<i32>, ParseIntError> = strings .iter() .map(|s| s.parse::<i32>()) .collect(); match numbers { Ok(nums) => println!("All numbers: {:?}", nums), Err(e) => println!("Parse error: {}", e), } // Filter out errors let valid_numbers: Vec<i32> = strings .iter() .filter_map(|s| s.parse().ok()) .collect(); println!("Valid numbers: {:?}", valid_numbers); // Partition Results let (successes, failures): (Vec<_>, Vec<_>) = strings .iter() .map(|s| s.parse::<i32>()) .partition(Result::is_ok); let successes: Vec<i32> = successes.into_iter().map(Result::unwrap).collect(); let failures: Vec<ParseIntError> = failures.into_iter().map(Result::unwrap_err).collect(); println!("Successes: {:?}", successes); println!("Failures count: {}", failures.len()); // Using try_fold for early termination let numbers = vec![1, 2, 3, 4, 5]; let result = numbers.iter().try_fold(0, |acc, &x| { if x == 3 { Err("Found 3!") } else { Ok(acc + x) } }); match result { Ok(sum) => println!("Sum: {}", sum), Err(msg) => println!("Stopped: {}", msg), } // Using custom error type match read_number_from_file("number.txt") { Ok(n) => println!("Number: {}", n), Err(AppError::Io(e)) => println!("IO error: {}", e), Err(AppError::Parse(e)) => println!("Parse error: {}", e), Err(AppError::Validation(msg)) => println!("Validation: {}", msg), } }

5. Methods on Enums

Implementing Methods

#[derive(Debug)] enum TrafficLight { Red, Yellow, Green, } impl TrafficLight { // Method that returns the next state fn next(&self) -> TrafficLight { match self { TrafficLight::Red => TrafficLight::Green, TrafficLight::Green => TrafficLight::Yellow, TrafficLight::Yellow => TrafficLight::Red, } } // Method that returns duration fn duration(&self) -> u32 { match self { TrafficLight::Red => 60, TrafficLight::Yellow => 5, TrafficLight::Green => 55, } } // Method with self parameter fn description(&self) -> String { match self { TrafficLight::Red => "Stop".to_string(), TrafficLight::Yellow => "Caution".to_string(), TrafficLight::Green => "Go".to_string(), } } // Associated function (no self) fn all() -> Vec<TrafficLight> { vec![TrafficLight::Red, TrafficLight::Yellow, TrafficLight::Green] } } fn main() { let light = TrafficLight::Red; println!("Current: {:?}", light); println!("Description: {}", light.description()); println!("Duration: {} seconds", light.duration()); let next = light.next(); println!("Next: {:?}", next); println!("All lights: {:?}", TrafficLight::all()); }

More Complex Method Examples

#[derive(Debug, Clone)] enum PaymentMethod { Cash, CreditCard { number: String, expiry: String, cvv: String }, PayPal { email: String }, BankTransfer { account: String, routing: String }, } impl PaymentMethod { fn is_valid(&self) -> bool { match self { PaymentMethod::Cash => true, PaymentMethod::CreditCard { number, expiry, cvv } => { // Simple validation logic number.len() == 16 && expiry.len() == 5 && cvv.len() == 3 && number.chars().all(|c| c.is_ascii_digit()) } PaymentMethod::PayPal { email } => { email.contains('@') && email.contains('.') } PaymentMethod::BankTransfer { account, routing } => { account.len() >= 8 && routing.len() == 9 && account.chars().all(|c| c.is_ascii_digit()) && routing.chars().all(|c| c.is_ascii_digit()) } } } fn fee_percentage(&self) -> f64 { match self { PaymentMethod::Cash => 0.0, PaymentMethod::CreditCard { .. } => 2.9, PaymentMethod::PayPal { .. } => 2.5, PaymentMethod::BankTransfer { .. } => 0.5, } } fn masked_display(&self) -> String { match self { PaymentMethod::Cash => "Cash".to_string(), PaymentMethod::CreditCard { number, .. } => { format!("**** **** **** {}", &number[12..]) } PaymentMethod::PayPal { email } => { let parts: Vec<&str> = email.split('@').collect(); if parts.len() == 2 { format!("{}@***.{}", &parts[0][..1], parts[1].split('.').last().unwrap_or("")) } else { "PayPal account".to_string() } } PaymentMethod::BankTransfer { .. } => "Bank transfer".to_string(), } } } fn main() { let methods = vec![ PaymentMethod::Cash, PaymentMethod::CreditCard { number: "1234567890123456".to_string(), expiry: "12/25".to_string(), cvv: "123".to_string(), }, PaymentMethod::PayPal { email: "[email protected]".to_string(), }, PaymentMethod::BankTransfer { account: "12345678".to_string(), routing: "123456789".to_string(), }, ]; for method in &methods { println!("{}", method.masked_display()); println!(" Valid: {}", method.is_valid()); println!(" Fee: {}%", method.fee_percentage()); } }

6. Enums with Generic Parameters

Generic Enums

// Generic enum #[derive(Debug)] enum MyOption<T> { Some(T), None, } // Enum with multiple generic parameters #[derive(Debug)] enum Either<L, R> { Left(L), Right(R), } // Enum with generic and specific constraints use std::fmt::Display; #[derive(Debug)] enum Result<T, E> { Ok(T), Err(E), } impl<T, E> Result<T, E> { fn is_ok(&self) -> bool { match self { Result::Ok(_) => true, Result::Err(_) => false, } } fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Result<U, E> { match self { Result::Ok(t) => Result::Ok(f(t)), Result::Err(e) => Result::Err(e), } } } // Enum with where clause use std::hash::Hash; #[derive(Debug)] enum MapEntry<K, V> where K: Hash + Eq, { Occupied { key: K, value: V }, Vacant { key: K }, } fn main() { let some_value: MyOption<i32> = MyOption::Some(42); let none_value: MyOption<String> = MyOption::None; println!("some: {:?}, none: {:?}", some_value, none_value); let either: Either<i32, String> = Either::Left(100); let either2: Either<i32, String> = Either::Right("hello".to_string()); println!("either: {:?}, either2: {:?}", either, either2); let result: Result<i32, String> = Result::Ok(42); println!("is_ok: {}, mapped: {:?}", result.is_ok(), result.map(|x| x * 2)); }

Const Generics with Enums

// Enum with const generic #[derive(Debug)] enum FixedSizeArray<T, const N: usize> { Filled([T; N]), Partial(Vec<T>), } impl<T, const N: usize> FixedSizeArray<T, N> { fn new() -> Self { FixedSizeArray::Partial(Vec::new()) } fn push(&mut self, value: T) -> Result<(), String> { match self { FixedSizeArray::Filled(_) => Err("Already filled".to_string()), FixedSizeArray::Partial(vec) => { vec.push(value); if vec.len() == N { let array = std::mem::take(vec).try_into().unwrap(); *self = FixedSizeArray::Filled(array); } Ok(()) } } } } // Enum with multiple const generics #[derive(Debug)] enum Matrix<T, const ROWS: usize, const COLS: usize> { Data([[T; COLS]; ROWS]), Empty, } fn main() { let mut arr = FixedSizeArray::<i32, 3>::new(); arr.push(1).unwrap(); arr.push(2).unwrap(); arr.push(3).unwrap(); println!("Fixed array: {:?}", arr); let matrix = Matrix::<i32, 2, 3>::Data([[1, 2, 3], [4, 5, 6]]); println!("Matrix: {:?}", matrix); }

7. Enums and Pattern Matching

Advanced Pattern Matching

#[derive(Debug)] enum ComplexEnum { Unit, Tuple(i32, String), Struct { x: i32, y: i32 }, Nested(Box<ComplexEnum>), Multiple(i32, Option<String>), } fn main() { let values = vec![ ComplexEnum::Unit, ComplexEnum::Tuple(42, "hello".to_string()), ComplexEnum::Struct { x: 10, y: 20 }, ComplexEnum::Nested(Box::new(ComplexEnum::Unit)), ComplexEnum::Multiple(100, Some("data".to_string())), ]; for value in &values { match value { ComplexEnum::Unit => println!("Unit variant"), ComplexEnum::Tuple(x, s) if x > &0 => { println!("Positive tuple: {}, {}", x, s); } ComplexEnum::Tuple(x, s) => { println!("Non-positive tuple: {}, {}", x, s); } ComplexEnum::Struct { x, y } if x == y => { println!("Square at ({}, {})", x, y); } ComplexEnum::Struct { x, y } => { println!("Rectangle at ({}, {})", x, y); } ComplexEnum::Nested(inner) => { println!("Nested: {:?}", inner); // Recursive matching if let ComplexEnum::Unit = **inner { println!("Contains unit!"); } } ComplexEnum::Multiple(num, Some(s)) => { println!("Multiple with data: {}, {}", num, s); } ComplexEnum::Multiple(num, None) => { println!("Multiple without data: {}", num); } } } }

Binding with @

#[derive(Debug)] enum Temperature { Celsius(i32), Fahrenheit(i32), } fn main() { let temps = vec![ Temperature::Celsius(25), Temperature::Celsius(40), Temperature::Fahrenheit(100), Temperature::Fahrenheit(32), ]; for temp in &temps { match temp { // @ binds the value to a variable while matching pattern temp @ Temperature::Celsius(t) if t > &30 => { println!("Hot day! {:?}", temp); } Temperature::Celsius(t) => { println!("Pleasant {}°C", t); } Temperature::Fahrenheit(f) if *f > 90 => { println!("Hot in Fahrenheit: {}", f); } Temperature::Fahrenheit(f) => { println!("Normal Fahrenheit: {}", f); } } } // Using @ with ranges let number = 42; match number { n @ 0..=9 => println!("Single digit: {}", n), n @ 10..=99 => println!("Two digits: {}", n), n @ 100..=999 => println!("Three digits: {}", n), n => println!("Large number: {}", n), } // @ with nested patterns enum Container { Box(Option<i32>), } let container = Container::Box(Some(42)); match container { Container::Box(Some(x @ 1..=50)) => { println!("Small number in box: {}", x); } Container::Box(Some(x)) => { println!("Large number in box: {}", x); } Container::Box(None) => { println!("Empty box"); } } }

Reference Patterns

#[derive(Debug)] enum Data { Number(i32), Text(String), } fn main() { let data = Data::Text(String::from("hello")); // Match with references match &data { Data::Number(n) => println!("Number: {}", n), Data::Text(s) => println!("Text: {}", s), } // ref keyword for borrowing match data { Data::Number(ref n) => println!("Borrowed number: {}", n), Data::Text(ref s) => println!("Borrowed text: {}", s), } // data still valid because we borrowed // ref mut for mutable borrowing let mut data = Data::Number(42); match data { Data::Number(ref mut n) => { *n += 10; println!("Modified number: {}", n); } Data::Text(ref mut s) => { s.push_str(" world"); println!("Modified text: {}", s); } } println!("After match: {:?}", data); // Matching on references let data_ref = &Data::Number(100); match data_ref { &Data::Number(n) => println!("Dereferenced: {}", n), &Data::Text(ref s) => println!("Dereferenced text: {}", s), } }

8. Enums in Collections

Vectors of Enums

#[derive(Debug)] enum Command { Push(i32), Pop, Print, Add, Subtract, Multiply, Divide, } struct Stack { values: Vec<i32>, } impl Stack { fn new() -> Self { Stack { values: Vec::new() } } fn execute(&mut self, cmd: Command) -> Option<i32> { match cmd { Command::Push(x) => { self.values.push(x); None } Command::Pop => self.values.pop(), Command::Print => { println!("Stack: {:?}", self.values); None } Command::Add => { let b = self.values.pop()?; let a = self.values.pop()?; self.values.push(a + b); None } Command::Subtract => { let b = self.values.pop()?; let a = self.values.pop()?; self.values.push(a - b); None } Command::Multiply => { let b = self.values.pop()?; let a = self.values.pop()?; self.values.push(a * b); None } Command::Divide => { let b = self.values.pop()?; let a = self.values.pop()?; if b != 0 { self.values.push(a / b); } None } } } } fn main() { let program = vec![ Command::Push(5), Command::Push(3), Command::Add, Command::Print, Command::Push(2), Command::Multiply, Command::Print, Command::Pop, Command::Print, ]; let mut stack = Stack::new(); for cmd in program { stack.execute(cmd); } }

HashMaps with Enums

use std::collections::HashMap; #[derive(Debug)] enum ConfigValue { String(String), Integer(i64), Float(f64), Boolean(bool), List(Vec<ConfigValue>), Map(HashMap<String, ConfigValue>), } impl ConfigValue { fn as_string(&self) -> Option<&String> { match self { ConfigValue::String(s) => Some(s), _ => None, } } fn as_integer(&self) -> Option<i64> { match self { ConfigValue::Integer(i) => Some(*i), _ => None, } } fn get(&self, key: &str) -> Option<&ConfigValue> { match self { ConfigValue::Map(map) => map.get(key), _ => None, } } } fn main() { let mut config = HashMap::new(); config.insert("host".to_string(), ConfigValue::String("localhost".to_string())); config.insert("port".to_string(), ConfigValue::Integer(8080)); config.insert("debug".to_string(), ConfigValue::Boolean(true)); let mut nested = HashMap::new(); nested.insert("username".to_string(), ConfigValue::String("admin".to_string())); nested.insert("password".to_string(), ConfigValue::String("secret".to_string())); config.insert("database".to_string(), ConfigValue::Map(nested)); // Access configuration if let Some(ConfigValue::String(host)) = config.get("host") { println!("Host: {}", host); } if let Some(ConfigValue::Integer(port)) = config.get("port") { println!("Port: {}", port); } // Nested access if let Some(db) = config.get("database") { if let Some(ConfigValue::String(user)) = db.get("username") { println!("DB User: {}", user); } } // Using helper methods if let Some(host) = config.get("host").and_then(|v| v.as_string()) { println!("Host (via method): {}", host); } }

9. Enums and Traits

Implementing Traits for Enums

use std::fmt; #[derive(Debug, Clone, PartialEq)] enum Animal { Dog { name: String, age: u32 }, Cat { name: String, lives: u32 }, Bird { species: String, can_fly: bool }, } // Implement Display trait impl fmt::Display for Animal { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self { Animal::Dog { name, age } => { write!(f, "Dog {} ({} years old)", name, age) } Animal::Cat { name, lives } => { write!(f, "Cat {} ({} lives)", name, lives) } Animal::Bird { species, can_fly } => { if *can_fly { write!(f, "Flying {}", species) } else { write!(f, "Flightless {}", species) } } } } } // Implement custom trait trait Speak { fn speak(&self) -> String; } impl Speak for Animal { fn speak(&self) -> String { match self { Animal::Dog { .. } => "Woof!".to_string(), Animal::Cat { .. } => "Meow!".to_string(), Animal::Bird { can_fly, .. } => { if *can_fly { "Tweet!".to_string() } else { "Squawk!".to_string() } } } } } // Implement Default impl Default for Animal { fn default() -> Self { Animal::Dog { name: "Rex".to_string(), age: 1, } } } fn main() { let animals = vec![ Animal::Dog { name: "Buddy".to_string(), age: 5 }, Animal::Cat { name: "Whiskers".to_string(), lives: 9 }, Animal::Bird { species: "Parrot".to_string(), can_fly: true }, ]; for animal in &animals { println!("{} says: {}", animal, animal.speak()); } let default_dog = Animal::default(); println!("Default: {}", default_dog); }

Trait Objects with Enums

// Trait for different types of errors trait AppError: std::fmt::Debug { fn severity(&self) -> u32; fn message(&self) -> String; } #[derive(Debug)] enum NetworkError { Timeout, ConnectionRefused, DnsFailure, } impl AppError for NetworkError { fn severity(&self) -> u32 { match self { NetworkError::Timeout => 2, NetworkError::ConnectionRefused => 4, NetworkError::DnsFailure => 3, } } fn message(&self) -> String { match self { NetworkError::Timeout => "Connection timed out".to_string(), NetworkError::ConnectionRefused => "Connection refused".to_string(), NetworkError::DnsFailure => "DNS lookup failed".to_string(), } } } #[derive(Debug)] enum DatabaseError { ConnectionFailed, QueryFailed(String), DuplicateEntry, } impl AppError for DatabaseError { fn severity(&self) -> u32 { match self { DatabaseError::ConnectionFailed => 5, DatabaseError::QueryFailed(_) => 3, DatabaseError::DuplicateEntry => 2, } } fn message(&self) -> String { match self { DatabaseError::ConnectionFailed => "Database connection failed".to_string(), DatabaseError::QueryFailed(msg) => format!("Query failed: {}", msg), DatabaseError::DuplicateEntry => "Duplicate entry".to_string(), } } } fn main() { let errors: Vec<Box<dyn AppError>> = vec![ Box::new(NetworkError::Timeout), Box::new(DatabaseError::QueryFailed("SELECT * FROM users".to_string())), Box::new(NetworkError::ConnectionRefused), Box::new(DatabaseError::ConnectionFailed), ]; for error in &errors { println!("Error: {}", error.message()); println!("Severity: {}", error.severity()); println!("Debug: {:?}", error); println!(); } // Sort errors by severity let mut errors = errors; errors.sort_by(|a, b| a.severity().cmp(&b.severity())); println!("Errors sorted by severity:"); for error in errors { println!(" {} (severity {})", error.message(), error.severity()); } }

10. Advanced Enum Patterns

State Machine with Enums

#[derive(Debug, PartialEq)] enum ConnectionState { Disconnected, Connecting { attempts: u32, timeout: u32 }, Connected { session_id: String, bytes_transferred: u64 }, Error(String), } struct Connection { state: ConnectionState, } impl Connection { fn new() -> Self { Connection { state: ConnectionState::Disconnected, } } fn connect(&mut self) { self.state = ConnectionState::Connecting { attempts: 0, timeout: 5, }; } fn disconnect(&mut self) { self.state = ConnectionState::Disconnected; } fn tick(&mut self) { use ConnectionState::*; match &mut self.state { Disconnected => { println!("Already disconnected"); } Connecting { attempts, timeout } => { if *timeout > 0 { *timeout -= 1; println!("Connecting... (attempt {}, timeout {})", attempts, timeout); } else if *attempts < 3 { *attempts += 1; *timeout = 5; println!("Retry attempt {}", attempts); } else { self.state = Error("Connection timeout".to_string()); } } Connected { session_id, bytes_transferred } => { *bytes_transferred += 1024; println!("Connected: {} ({} bytes)", session_id, bytes_transferred); } Error(msg) => { println!("Error state: {}", msg); } } } fn on_connected(&mut self, session_id: String) -> Result<(), String> { match &self.state { ConnectionState::Connecting { .. } => { self.state = ConnectionState::Connected { session_id, bytes_transferred: 0, }; Ok(()) } state => Err(format!("Cannot connect from state: {:?}", state)), } } } fn main() { let mut conn = Connection::new(); conn.connect(); for _ in 0..20 { conn.tick(); if conn.state == ConnectionState::Connected { break; } } // Simulate successful connection let _ = conn.on_connected("sess_123".to_string()); for _ in 0..5 { conn.tick(); } }

Visitor Pattern with Enums

#[derive(Debug)] enum Expression { Constant(i32), Add(Box<Expression>, Box<Expression>), Subtract(Box<Expression>, Box<Expression>), Multiply(Box<Expression>, Box<Expression>), Divide(Box<Expression>, Box<Expression>), Negate(Box<Expression>), } impl Expression { fn evaluate(&self) -> Option<i32> { match self { Expression::Constant(n) => Some(*n), Expression::Add(l, r) => Some(l.evaluate()? + r.evaluate()?), Expression::Subtract(l, r) => Some(l.evaluate()? - r.evaluate()?), Expression::Multiply(l, r) => Some(l.evaluate()? * r.evaluate()?), Expression::Divide(l, r) => { let r_val = r.evaluate()?; if r_val == 0 { None } else { Some(l.evaluate()? / r_val) } } Expression::Negate(e) => Some(-e.evaluate()?), } } fn depth(&self) -> usize { match self { Expression::Constant(_) => 1, Expression::Add(l, r) | Expression::Subtract(l, r) | Expression::Multiply(l, r) | Expression::Divide(l, r) => { 1 + l.depth().max(r.depth()) } Expression::Negate(e) => 1 + e.depth(), } } fn count_ops(&self) -> usize { match self { Expression::Constant(_) => 0, Expression::Add(l, r) | Expression::Subtract(l, r) | Expression::Multiply(l, r) | Expression::Divide(l, r) => { 1 + l.count_ops() + r.count_ops() } Expression::Negate(e) => 1 + e.count_ops(), } } } fn main() { // Build expression: (3 + 4) * (5 - 2) let expr = Expression::Multiply( Box::new(Expression::Add( Box::new(Expression::Constant(3)), Box::new(Expression::Constant(4)) )), Box::new(Expression::Subtract( Box::new(Expression::Constant(5)), Box::new(Expression::Constant(2)) )) ); println!("Expression depth: {}", expr.depth()); println!("Number of operations: {}", expr.count_ops()); println!("Result: {:?}", expr.evaluate()); }

11. Performance Considerations

Memory Layout

use std::mem; #[derive(Debug)] enum SimpleEnum { A, B, C, } #[derive(Debug)] enum DataEnum { Empty, Number(i32), Text(String), Large([u8; 1024]), } fn main() { // Size of enums println!("Size of SimpleEnum: {} bytes", mem::size_of::<SimpleEnum>()); println!("Size of Option<i32>: {} bytes", mem::size_of::<Option<i32>>()); println!("Size of Option<&i32>: {} bytes", mem::size_of::<Option<&i32>>()); println!("Size of DataEnum: {} bytes", mem::size_of::<DataEnum>()); println!("Size of DataEnum::Empty: {} bytes", mem::size_of_val(&DataEnum::Empty)); println!("Size of DataEnum::Number(42): {} bytes", mem::size_of_val(&DataEnum::Number(42))); // Alignment println!("Alignment of DataEnum: {} bytes", mem::align_of::<DataEnum>()); // Using Box to reduce size for large variants #[derive(Debug)] enum OptimizedEnum { Small(i32), Large(Box<[u8; 1024]>), // Box reduces size } println!("Size of OptimizedEnum: {} bytes", mem::size_of::<OptimizedEnum>()); }

Zero-Cost Abstractions

fn main() { // Enums are zero-cost abstractions let numbers = vec![1, 2, 3, 4, 5]; // Using Option - no runtime overhead fn find_even(numbers: &[i32]) -> Option<i32> { for &n in numbers { if n % 2 == 0 { return Some(n); } } None } // Using Result - no runtime overhead fn divide(a: i32, b: i32) -> Result<i32, &'static str> { if b == 0 { Err("division by zero") } else { Ok(a / b) } } // The compiler optimizes these to efficient code if let Some(even) = find_even(&numbers) { println!("Found even: {}", even); } match divide(10, 2) { Ok(result) => println!("Division result: {}", result), Err(e) => println!("Error: {}", e), } }

12. Testing and Documentation

Testing Enums

#[derive(Debug, PartialEq)] enum HttpStatus { Ok = 200, NotFound = 404, InternalServerError = 500, } impl HttpStatus { fn from_code(code: u16) -> Option<Self> { match code { 200 => Some(HttpStatus::Ok), 404 => Some(HttpStatus::NotFound), 500 => Some(HttpStatus::InternalServerError), _ => None, } } fn is_success(&self) -> bool { matches!(self, HttpStatus::Ok) } fn is_client_error(&self) -> bool { matches!(self, HttpStatus::NotFound) } fn is_server_error(&self) -> bool { matches!(self, HttpStatus::InternalServerError) } } #[cfg(test)] mod tests { use super::*; #[test] fn test_from_code() { assert_eq!(HttpStatus::from_code(200), Some(HttpStatus::Ok)); assert_eq!(HttpStatus::from_code(404), Some(HttpStatus::NotFound)); assert_eq!(HttpStatus::from_code(500), Some(HttpStatus::InternalServerError)); assert_eq!(HttpStatus::from_code(418), None); } #[test] fn test_status_classification() { assert!(HttpStatus::Ok.is_success()); assert!(!HttpStatus::Ok.is_client_error()); assert!(!HttpStatus::Ok.is_server_error()); assert!(HttpStatus::NotFound.is_client_error()); assert!(!HttpStatus::NotFound.is_success()); assert!(!HttpStatus::NotFound.is_server_error()); assert!(HttpStatus::InternalServerError.is_server_error()); assert!(!HttpStatus::InternalServerError.is_success()); assert!(!HttpStatus::InternalServerError.is_client_error()); } #[test] fn test_discriminant_values() { assert_eq!(HttpStatus::Ok as u16, 200); assert_eq!(HttpStatus::NotFound as u16, 404); assert_eq!(HttpStatus::InternalServerError as u16, 500); } }

Documentation Examples

/// Represents different types of network events /// /// # Examples /// /// ``` /// use mylib::NetworkEvent; /// /// let event = NetworkEvent::ConnectionEstablished { /// address: "192.168.1.1".to_string(), /// port: 8080, /// }; /// /// match event { /// NetworkEvent::ConnectionEstablished { address, port } => { /// println!("Connected to {}:{}", address, port); /// } /// _ => println!("Other event"), /// } /// ``` #[derive(Debug)] pub enum NetworkEvent { /// A new connection was established ConnectionEstablished { /// Remote address address: String, /// Remote port port: u16, }, /// Data was received DataReceived { /// The data that was received data: Vec<u8>, /// Number of bytes received size: usize, }, /// Connection was closed ConnectionClosed { /// Reason for closure, if any reason: Option<String>, }, /// An error occurred Error(String), } impl NetworkEvent { /// Returns a string describing the event /// /// # Examples /// /// ``` /// # use mylib::NetworkEvent; /// let event = NetworkEvent::ConnectionClosed { reason: None }; /// assert_eq!(event.description(), "Connection closed"); /// ``` pub fn description(&self) -> &str { match self { NetworkEvent::ConnectionEstablished { .. } => "Connection established", NetworkEvent::DataReceived { .. } => "Data received", NetworkEvent::ConnectionClosed { .. } => "Connection closed", NetworkEvent::Error(_) => "Error occurred", } } /// Returns true if this event indicates an error condition pub fn is_error(&self) -> bool { matches!(self, NetworkEvent::Error(_)) } }

Conclusion

Enums are one of Rust's most powerful features:

Key Takeaways

1. Type Safety: Enums ensure only valid states are representable
2. Pattern Matching: Work seamlessly with match for exhaustive handling
3. Data Carriers: Each variant can hold different types of data
4. Option and Result: Built-in enums for common patterns
5. Memory Efficiency: Only as large as the largest variant plus tag
6. Expressiveness: Perfect for modeling complex domains

Common Patterns

Pattern	Use Case	Example
Simple Enum	Fixed set of values	Direction { North, South, ... }
Enum with Data	Variants need associated data	Message::Write(String)
Option	Optional values	Option<T>
Result	Error handling	Result<T, E>
State Machine	Modeling states	ConnectionState
Visitor	Processing variants	Expression

Best Practices

1. Make impossible states unrepresentable: Use enums to encode valid states in the type system
2. Use exhaustive matching: Let the compiler ensure all variants are handled
3. Prefer Option over custom null-like types
4. Use Result for fallible operations
5. Implement common traits (Debug, Clone, PartialEq) for enums
6. Consider Box for large variants to reduce memory footprint
7. Use match with guards for complex conditional logic

Enums are fundamental to idiomatic Rust code and mastering them is essential for writing robust, expressive programs.