Enums

Enums are a fundamental feature in Rust that let you define a type that can be one of several distinct variants. Enums make it easier to represent a set of related states or options cleanly and effectively.

In this challenge, you will implement a simple TrafficLight enum to represent the states of a traffic light: Red, Yellow, and Green. Each variant will be a unit struct with no associated data.

Your Task

Create an enum TrafficLight with three variants:

Red representing the red light.
Yellow representing the yellow light.
Green representing the green light.

Write a function light_action that takes a TrafficLight and returns a string describing the action associated with the light.

For Red, return "Stop".
For Yellow, return "Caution".
For Green, return "Go".

Hints

Click here to reveal hints

Use the match statement to handle each enum variant.

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

Icarus

IcarusxB

2 hours ago

4.41ms

81.28kb

pub enum TrafficLight {
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
match light {
    TrafficLight::Red => "Stop",
    TrafficLight::Yellow => "Caution",
    TrafficLight::Green => "Go",
}
}

Tboot

tboot-0510

a day ago

2.80ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

Muhammad Najib Bala

NAJIB-B

a day ago

2.87ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go"
    }
}

vojta stefan

vojtastefan

a day ago

2.77ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light{
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go"
    }
}

Pranav Garg

PranavGarg01

2 days ago

3.29ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go"
    }
}

Hung Dinh

nhdinh

2 days ago

6.09ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

Léa Narzis

lean-apple

2 days ago

2.86ms

81.28kb

pub enum TrafficLight {
    Red,
    Green,
    Yellow,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution", 
        TrafficLight::Green => "Go" 
    }
}

amaneru

7ma8no9

3 days ago

4.70ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

AnKarl

Zythophilus

4 days ago

3.97ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

AKA.MoneyTaker

M4Bo2

5 days ago

2.90ms

81.28kb

// Define the TrafficLight enum with three variants
pub enum TrafficLight {
    Red,
    Yellow,
    Green,
}
// Function to return the action associated with a TrafficLight variant
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Match the TrafficLight variant and return the corresponding action
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}
// Example usage
fn main() {
    let red_light = TrafficLight::Red;
    let yellow_light = TrafficLight::Yellow;
    let green_light = TrafficLight::Green;
    println!("Red light action: {}", light_action(&red_light));    // Output: Stop
    println!("Yellow light action: {}", light_action(&yellow_light)); // Output: Caution
    println!("Green light action: {}", light_action(&green_light));   // Output: Go
}

Artyom Chebotarev

Derik117

5 days ago

3.47ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => {
            "Stop"
        }
        TrafficLight::Yellow => {
            "Caution"
        }
        TrafficLight::Green => {
            "Go"
        }
    }
}

Kamuran

karapy

5 days ago

2.94ms

81.28kb

pub enum TrafficLight {
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

Dimas Avrian Fachriza.

FForFachriza

5 days ago

2.89ms

85.88kb

pub enum TrafficLight {
    Red,
    Yellow,
    Green
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

zawwwu

6 days ago

2.93ms

81.28kb

pub enum TrafficLight {
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    match light {
        TrafficLight::Red => {
            "Stop"
        }
        TrafficLight::Yellow => {
            "Caution"
        }
        TrafficLight::Green => {
            "Go"
        }
    }
}

Franklin Chen

FranklinChen

7 days ago

3.27ms

81.28kb

pub enum TrafficLight {
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

Éric Villani

TheTrueCaligari

8 days ago

3.08ms

81.28kb

pub enum TrafficLight {
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    match light {
        TrafficLight::Red =>     "Stop",
        TrafficLight::Yellow =>  "Caution",
        TrafficLight::Green =>   "Go"
    }
}

Nanle100

8 days ago

2.77ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

Lê Minh Quân

aleister1102

8 days ago

3.21ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go"
    }
}

Yi Hao

leongyihao

10 days ago

3.92ms

81.28kb

pub enum TrafficLight {
    Red,
    Yellow,
    Green
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go"
    }
}

Dyaa Adel

dyaa-adel

11 days ago

4.40ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go"
    }
}

Dyaa Adel

dyaa-adel

11 days ago

3.21ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go"
    }
}

TiagONTOP

11 days ago

3.35ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

Ayushman Rathore

Spartan09

11 days ago

3.70ms

81.28kb

pub enum TrafficLight {
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

norabbito

11 days ago

3.52ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match &light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

Anıl Şenay

anilsenay

12 days ago

3.01ms

81.28kb

pub enum TrafficLight {
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

Christopher Kolbe

chkolbe

12 days ago

4.96ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

Vladimir

PavluninVladimir

12 days ago

5.83ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

Vladimir

PavluninVladimir

12 days ago

3.15ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => return "Stop",
        TrafficLight::Yellow => return "Caution",
        TrafficLight::Green => return "Go",
    }
}

Jordan

Jordan-Haidee

13 days ago

2.65ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red, 
    Yellow, 
    Green
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop", 
        TrafficLight::Yellow => "Caution", 
        TrafficLight::Green => "Go", 
    }
}

VLund

VladikPopik

14 days ago

2.91ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

SeinPierre

14 days ago

2.75ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

Kyle Diaz

kylediaz

15 days ago

2.66ms

81.28kb

pub enum TrafficLight {
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

Guilherme Cesário Strachan

strachan

15 days ago

2.96ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Green,
    Yellow,
    Red
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Green => "Go",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Red => "Stop"
    }
}

McToady.eth

McCoady

16 days ago

2.63ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

Kenneth Love

kennethlove

16 days ago

3.25ms

81.28kb

pub enum TrafficLight {
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

Prafful

iamsahu

17 days ago

3.05ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go"
    }
}

ludovicknecht

18 days ago

2.75ms

81.28kb

pub enum TrafficLight {
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    match light {
        TrafficLight::Red => return "Stop",
        TrafficLight::Yellow => return "Caution",
        TrafficLight::Green => return "Go"
    }
}

Douglas Campbell

CampbellD84

19 days ago

3.86ms

81.28kb

pub enum TrafficLight {
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go"
    }
}

Whisper_icoma

1378046967

19 days ago

3.40ms

81.28kb


pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go"
    }
}

Muhammad-Dennis

19 days ago

3.08ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go"
    }
}

Diego Maia

diegocmsantos

19 days ago

2.81ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Green,
    Yellow,
    Red,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    match light {
        TrafficLight::Green => "Go",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Red => "Stop",
    }
}

automata-studio

20 days ago

3.34ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

kosay

sarub0b0

20 days ago

9.84ms

81.28kb

pub enum TrafficLight {
    Red,
    Yellow,
    Green
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

Denis SOURON

Brack0

20 days ago

3.49ms

81.28kb

pub enum TrafficLight {
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

Donald Huber-Youmans

dHuberYoumans

21 days ago

2.77ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow=> "Caution",
        TrafficLight::Green =>"Go",
    }
}

manuelmj

21 days ago

2.93ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
     Red,
     Yellow,
     Green
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light{
       TrafficLight::Red => "Stop",
       TrafficLight::Yellow => "Caution",
       TrafficLight::Green => "Go"
    }
}

dcodes

dcodesdev

21 days ago

6.15ms

81.28kb

pub enum TrafficLight {
    Red,
    Green,
    Yellow
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Green => "Go",
        TrafficLight::Yellow => "Caution",
    }
}

buu

bushuai

21 days ago

3.07ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}

alemack17

22 days ago

4.40ms

81.28kb

pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    match light{
        TrafficLight::Red=> "Stop",
        TrafficLight::Yellow=> "Caution",
        TrafficLight::Green=> "Go",
    }
}

TeDeMos

22 days ago

2.99ms

81.28kb

pub enum TrafficLight {
    Red,
    Yellow,
    Green,
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    match light {
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution",
        TrafficLight::Green => "Go",
    }
}