Enum Basics
enum Name {
Variant1,
Variant2(Type),
Variant3 { field: Type },
}
let value = Name::Variant1;Defining a Simple Enum
An enum defines a type whose value can be exactly one of a fixed set of named variants, useful for representing a closed set of possibilities.
Example: Defining a Simple Enum
// Auto-generate #[derive(Debug)] for the type below
#[derive(Debug)]
// Define an enum `Direction` listing its possible variants
enum Direction {
North,
South,
East,
West,
}
// Entry point: execution of the program starts here
fn main() {
// Declare an immutable variable `heading`, set to `Direction::North`
let heading = Direction::North;
// Print "{:?}" to the console, substituting in `heading` (with a trailing newline)
println!("{:?}", heading);
}Login to try C/C++/Java/PHP code in the editor
Enums With Data
Unlike simple labels, Rust enum variants can carry their own associated data, and different variants can carry different types and amounts of data.
Example: Enums With Data
// Auto-generate #[derive(Debug)] for the type below
#[derive(Debug)]
// Define an enum `Shape` listing its possible variants
enum Shape {
Circle(f64),
Rectangle(f64, f64),
}
// Entry point: execution of the program starts here
fn main() {
// Declare an immutable variable `shapes`, set to `[Shape::Circle(2.0), Shape::Rectangle(3.0, 4.0)]`
let shapes = [Shape::Circle(2.0), Shape::Rectangle(3.0, 4.0)];
// Loop over `shapes.iter()`, binding each item to `s`
for s in shapes.iter() {
// Print "{:?}" to the console, substituting in `s` (with a trailing newline)
println!("{:?}", s);
}
}Login to try C/C++/Java/PHP code in the editor
Matching on an Enum
match is the primary way to inspect which variant an enum value holds and to extract any data it carries, with a separate arm for each possible variant.
Example: Matching on an Enum
// Define an enum `TrafficLight` listing its possible variants
enum TrafficLight {
Red,
Yellow,
Green,
}
// Entry point: execution of the program starts here
fn main() {
// Declare an immutable variable `light`, set to `TrafficLight::Yellow`
let light = TrafficLight::Yellow;
// Match on `light` and branch by pattern
match light {
TrafficLight::Red => println!("Stop"),
TrafficLight::Yellow => println!("Slow down"),
TrafficLight::Green => println!("Go"),
}
}Login to try C/C++/Java/PHP code in the editor
Comparing Enum Values
Deriving PartialEq on an enum allows comparing its values directly with ==, which is useful for simple checks without writing a full match.
Example: Comparing Enum Values
// Auto-generate #[derive(PartialEq, Debug)] for the type below
#[derive(PartialEq, Debug)]
// Define an enum `Status` listing its possible variants
enum Status {
Active,
Inactive,
}
// Entry point: execution of the program starts here
fn main() {
// Declare an immutable variable `current`, set to `Status::Active`
let current = Status::Active;
// Print "Is active: {}" to the console, substituting in `current == Status::Active` (with a trailing newline)
println!("Is active: {}", current == Status::Active);
}Login to try C/C++/Java/PHP code in the editor
- Forgetting an enum variant can carry its own data, not just be a plain label like in some other languages.
- Trying to compare enum variants with
==before derivingPartialEqon the enum. - Assuming enum variant names are globally unique -- they must be qualified with
EnumName::Variantunless imported.
- An enum defines a type that can be exactly one of several named variants.
- Variants can optionally carry associated data, including different data per variant.
- Enum values are typically handled with
matchto branch on which variant is present. - Deriving traits like
DebugandPartialEqon an enum enables printing and comparison.
Chapter Quiz — Complete all 7 topics to unlock
0/7 topics done
Complete these topics first: