Enums in Rust: Algebraic Types and Option Handling

An enum in Rust is a type that can represent one of several possible variants.

If you come from C, C#, or Java, you probably think of an enum as a nice way to assign names to integer values.

• Color.Red is 0.
• Color.Green is 1.

It’s useful for state machines or configurations, but not much else.

In Rust, enums are a completely different beast. Rust adopts the concept of Algebraic Data Types (ADTs) from functional languages (like Haskell).

This means that an enum in Rust doesn’t just tell us “which variant it is,” but each variant can contain different data inside it.

Simple Enums

Let’s start with the basics, what you already know. An Enum allows us to define a type that can be one of several possible variants.

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

fn main() {
    let direction = Direction::North;
}

Nothing new so far. We can use it to add clarity to code instead of using magic numbers (0, 1, 2, 3).

Enums with Data

Here’s where it gets interesting. In Rust, we don’t need to create a separate struct to associate data with a variant. We can store data directly inside the enum variant.

Imagine we want to model IP addresses. We have two standards: V4 and V6.

• A V4 address is four 8-bit numbers (e.g., 127.0.0.1).
• A V6 address is a long String.

In C# or Java, we would have to create a base class IpAddr and two subclasses, or a struct with optional fields. In Rust, we model it like this:

enum IpAddr {
    V4(u8, u8, u8, u8), // This variant stores 4 bytes
    V6(String),         // This variant stores a String
}

fn main() {
    let home = IpAddr::V4(127, 0, 0, 1);
    let loopback = IpAddr::V6(String::from("::1"));
}

A Message System

To see the real flexibility, look at this example of an enum that defines the messages that can be sent in an application:

enum Message {
    Quit,                       // No associated data (like a C enum)
    Move { x: i32, y: i32 },    // Has named fields (like a Struct)
    Write(String),              // Has a single String (like a Tuple Struct)
    ChangeColor(i32, i32, i32), // Has three integers (like a Tuple)
}

If we wanted to model this only with structs, we would need four different types and some additional mechanism to treat them as “any message.” With the enum, everything is grouped under the Message type.

Methods on Enums

Just like Structs, Enums can also have impl blocks to define methods.

impl Message {
    fn execute(&self) {
        // Logic would go here (using match, which we'll see in the next article)
    }
}

fn main() {
    let m = Message::Write(String::from("Hello"));
    m.execute();
}

The Option Enum

In most languages, there is the concept of null (or nil, None). It’s the “billion-dollar mistake” (the costliest error in history) because trying to use a null value makes the program crash (NullReferenceException).

Ordinary types and references in Rust do not use null as a valid value. Raw pointers can be null, especially when interoperating with other languages, but they fall outside the usual guarantees of references.

So how do we express that something might not exist? (For example, searching for a user in a database and not finding them).

Rust uses a generic Enum included in the standard library called Option.

enum Option<T> {
    None,    // Represents the absence of a value (like null)
    Some(T), // Represents that there IS a value of type T
}

This enum is so important that Rust imports it automatically (you don’t need to write Option::Some, just Some).

let number: i32 = 5;
let optional_number: Option<i32> = Some(5);
let empty_number: Option<i32> = None;

// let sum = number + optional_number; // ❌ ERROR!