How to Iterate Through Enum Values in Rust

By the end of this page, you will understand why Rust enums do not automatically provide a values() method like Java enums, and how to iterate over enum variants using common Rust patterns. You will also see practical examples, trade-offs, and how this is handled in real Rust codebases.

Rust enums and Java enums look similar at first, but they are designed differently.

In Java, enums are a special kind of class with built-in runtime support for listing all values using methods like values(). In Rust, an enum is a type that can represent one of several variants, but Rust does not automatically generate a list of all variants.

For example:

enum Direction {
    North,
    South,
    East,
    West,
}

This tells Rust that a Direction can be one of four variants. However, Rust does not keep a built-in array or registry of those variants for iteration.

Why? Because Rust enums are more general than Java enums:

• Variants can hold data
• Enums are often used for pattern matching, not just named constants
• Rust prefers explicitness over hidden runtime features

That means if you want to iterate over every variant, you usually choose one of these approaches:

• Define a constant array containing all variants
• Implement a helper method that returns all variants
• Use a crate such as strum to derive iteration support

This matters in real programming when you need to:

• render all possible options in a UI
• validate user input against allowed values
• loop through states or directions in a game
• test all enum variants

So the core idea is: Rust does not provide enum iteration automatically, but it is easy to add using explicit patterns.

Think of a Rust enum like a set of labeled cards in a box.

• The enum definition tells you which cards are allowed.
• But Rust does not automatically hand you a stack containing one of each card.
• If you want to loop over them, you must prepare that stack yourself.

In Java, the language gives you the stack automatically with values(). In Rust, you usually create that stack explicitly, such as:

const ALL_DIRECTIONS: [Direction; 4] = [
    Direction::North,
    Direction::South,
    Direction::East,
    Direction::West,
];

Now you have a concrete collection to iterate over.

So the mental model is:

• enum defines the possible choices
• an array or helper provides the iterable list of choices

Basic pattern: define all variants in an array

A common beginner-friendly Rust approach is to store all enum variants in a constant array.

#[derive(Debug, Clone, Copy)]
enum Direction {
    North,
    South,
    East,
    West,
}

const ALL_DIRECTIONS: [Direction; 4] = [
    Direction::North,
    Direction::South,
    Direction::East,
    Direction::West,
];

fn main() {
    for dir in ALL_DIRECTIONS {
        println!("{:?}", dir);
    }
}

Why Clone and Copy?

For small enums without attached data, deriving Copy is convenient. It lets each value be copied cheaply when iterating.

Alternative: return a slice from an associated function

#[derive(Debug, Clone, Copy)]
enum Direction {
    North,
    South,
    East,
    West,
}

impl Direction {
    fn all() -> &'static [Direction] {
        &[
            Direction::North,
            Direction::South,
            Direction::East,
            Direction::West,
        ]
    }
}

 () {
       Direction::() {
        (, dir);
    }
}

Consider this example:

#[derive(Debug, Clone, Copy)]
enum Direction {
    North,
    South,
    East,
    West,
}

const ALL_DIRECTIONS: [Direction; 4] = [
    Direction::North,
    Direction::South,
    Direction::East,
    Direction::West,
];

fn main() {
    for dir in ALL_DIRECTIONS {
        println!("Moving {:?}", dir);
    }
}

Here is what happens step by step:

1. enum Direction defines four possible values.
2. ALL_DIRECTIONS creates an array containing one of each variant.
3. main() starts running.
4. The for loop takes each item from ALL_DIRECTIONS one at a time.
5. On the first iteration, dir is Direction::North.
6. println! prints Moving North.
7. The loop repeats for South, East, and .

Iterating through enum variants is useful in many practical situations.

Building menu options

If your app has a list of available modes:

enum Theme {
    Light,
    Dark,
    System,
}

You might loop through all themes to render a settings menu.

Game movement or state logic

A game may use directions such as North, South, East, and West to test possible moves.

Validation and parsing

You may want to compare user input against all allowed enum values and display valid options.

Testing all variants

When writing tests, iterating over all enum variants helps verify that every option behaves correctly.

Data export or reporting

If an enum represents categories, statuses, or roles, iterating over all variants can help generate reports or summaries.

In real Rust projects, developers usually use enum iteration in a few common patterns.

Configuration and option lists

An enum may represent a fixed set of supported values, such as log levels, themes, regions, or output formats. A helper like all() is often used to populate dropdowns, CLI help text, or config validation.

Validation

A request parser may convert strings into enum variants. If parsing fails, code can iterate through all valid values to build a useful error message.

Tests

Developers often iterate through every variant in tests to avoid missing edge cases.

#[test]
fn all_directions_have_labels() {
    for dir in Direction::all() {
        let label = match dir {
            Direction::North => "North",
            Direction::South => "South",
            Direction::East => "East",
            Direction::West => "West",
        };
        assert!(!label.is_empty());
    }
}

Guarded APIs

Sometimes a public API exposes Direction::all() so other parts of the codebase have one consistent source of truth.

Crate-based derive patterns

Mistake 1: expecting a built-in values() method

This does not exist in Rust:

for dir in Direction::values() {
    println!("{:?}", dir);
}

Fix

Create your own list of variants or use a crate like strum.

Mistake 2: forgetting to keep the manual list updated

Broken design:

#[derive(Debug, Clone, Copy)]
enum Direction {
    North,
    South,
    East,
    West,
    Up,
}

const ALL_DIRECTIONS: [Direction; 4] = [
    Direction::North,
    Direction::South,
    Direction::East,
    Direction::West,
];

Here, Up exists in the enum but is missing from the array.

Fix

Whenever you add a variant, update the array or use strum to avoid manual duplication.

Mistake 3: trying to iterate enums with data as if they were simple fixed values

enum  {
    Quit,
    (, ),
    (),
}

Rust enums vs Java enums

#[derive(Debug, Clone, Copy)]
enum Direction {
    North,
    South,
    East,
    West,
}

const ALL_DIRECTIONS: [Direction; 4] = [
    Direction::North,
    Direction::South,
    Direction::East,
    Direction::West,
];

for dir in ALL_DIRECTIONS {
    println!("{:?}", dir);
}

Quick rules

• Rust enums do not have a built-in values() method.
• To iterate variants, define a manual list or use a crate.
• Copy is useful for small enums without data.
• If variants contain data, full iteration may not make sense.
• strum is a popular crate for EnumIter.

Handy pattern

impl Direction {
    fn all() -> &'static [Direction] {
        &[
            Direction::North,
            Direction::South,
            Direction::East,
            Direction::West,
        ]
    }
}

With strum

Is there a built-in values() function for Rust enums?

No. Rust does not automatically generate a values() method for enums.

What is the simplest way to iterate over enum variants in Rust?

Create a constant array containing all variants and loop over it.

Can I make Rust enums behave more like Java enums?

Yes. A common pattern is to add an all() method that returns a slice of all variants.

What crate is commonly used for enum iteration in Rust?

strum is a popular crate. It can derive iteration support with EnumIter.

Does enum iteration work for enums with data fields?

Not automatically in a general way. Variants with fields can represent many possible values.

Should I use a manual array or a crate?

Use a manual array for small, simple projects. Use a crate if you want less boilerplate or have many enums.

Why does Rust not provide this automatically?

Because Rust enums are more flexible than simple named constants, and Rust generally prefers explicit patterns over hidden runtime behavior.

• Pattern matching — Rust enums are most commonly used with match to handle each variant.
• Associated functions — Useful for adding methods like all() to an enum.
• Traits and derives — Traits like Debug, Copy, and derive macros make enums easier to use.
• Slices and arrays — These are the standard collections used to store enum variants for iteration.
• Iterators — Rust loops are built on iterators, so understanding them helps with enum iteration.
• Enums with data — Important for understanding why some enums cannot be fully iterated in a simple way.
• Crates and procedural macros — Libraries like strum extend Rust with convenient enum utilities.