Aniket Botre

Posted on

# Day 13: Rust Enums β Unleashing the Power of Variants! πͺπ¦

Ahoy, fellow code navigators! On this auspicious Day 13 of my #100DaysOfCode Rust voyage, we set sail into the enchanting seas of Enums β a versatile feature in Rust that brings forth a legion of coding possibilities. πβ¨

## Enums: The Spice of Rust πΆοΈ

In Rust, Enums, short for enumerations, are a unique data type that lets you define a type by enumerating its possible variants. They are similar to algebraic data types in functional programming. Imagine enums as a magical box that can hold different types of data, but only one at a time.

The basic syntax for defining an enum in Rust involves the enum keyword followed by the name of the enum and a set of variants enclosed in curly braces.

For example:

``````// A simple Enum named 'Direction' with variants
enum Direction {
North,
South,
East,
West,
}
``````

Here, we've conjured an Enum called `Direction` with four magical variants β `North`, `South`, `East`, and `West`. Each variant represents a unique aspect, akin to cardinal directions.

## Enumerating Variants with Values π¨

Enums can carry additional data, adding a touch of magic to their variants. Behold the power of associating values with each variant!

``````enum IpAddr {
V4(String),
V6(String),
}
``````

In the example above, `IpAddr` can be either `V4` or `V6`, each with a String value. But it can't be both `V4` and `V6` at the same time!

## Enums and Match Magic π©

One of the key powers of enums in Rust is how they interact with the `match` control flow operator. `Match` allows you to compare a value against a series of patterns and execute code based on it, making it a potent tool for handling enums.

``````let home = IpAddr::V4(String::from("127.0.0.1"));

match home {
}
``````

In the above example, we're using `match` to handle different variants of the `IpAddr` enum. Depending on whether `home` is an `IpAddr::V4` or `IpAddr::V6`, different code gets executed.

## Enums and Methods: A Dynamic Duo

You're not just limited to defining data in your enums. Rust also allows you to define methods on enums. These methods can use `match` to provide different behavior based on the enum variant.
Here's an example:

``````enum TrafficLight {
Red,
Yellow,
Green,
}

impl TrafficLight {
fn time(&self) -> u8 {
match self {
TrafficLight::Red => 60,
TrafficLight::Yellow => 10,
TrafficLight::Green => 30,
}
}
}

let red = TrafficLight::Red;
println!("Red light for {} seconds", red.time());
// Output: Red light for 60 seconds
``````

In this example, we've defined a time method on the TrafficLight enum that returns how long each light should be displayed.

## Enums and Lifelong Learning β A Never-Ending Tale π

As we conclude our exploration of Enums, let's cherish the truth that in the vast tapestry of coding, learning is a saga that never ends. Enums, with their versatile variants and pattern-matching prowess, add a fascinating chapter to our Rustic tale.

Embrace the variants, my fellow code wanderers! ππ»β¨