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

KuuShyn

4 hours ago

4.01ms

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"
    }
}

Luigi Terrone

LuigiTer

21 hours ago

2.74ms

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"
    }
}

Karol Płatkowski

spoohie

2 days ago

8.33ms

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"
    }
}

Heino Mortensen

hmortensen83

2 days ago

3.26ms

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",
    }
}

0x0f1

Paul4673

2 days ago

2.97ms

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",
    }
}

noomcreator

3 days 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"
    }
}

dattruongdev

3 days ago

3.84ms

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"
    }
}

Kr0wZ

4 days ago

3.23ms

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",
    }
}

silaskoemen

5 days ago

2.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",
    }
}

Tri Nguyen

nguyentri

5 days ago

2.89ms

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"
    }
}

Sarthak Mishra

sithtsar

5 days ago

3.06ms

81.28kb

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

xxxxsk

7 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"
    }
}

Pierre Gordo

PierreGordo

8 days ago

3.58ms

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",
    }
}

Gomathi Shankar

gomathishankar37

8 days ago

3.84ms

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",
    }
}

Satya Sundar Sahu

satya200

8 days ago

4.74ms

81.28kb

#[derive(PartialEq)]
pub enum TrafficLight {
    // Define enum variants here
    Red,
    Yellow,
    Green
}
pub fn light_action(light: &TrafficLight) -> &'static str {
    // Your code here...
    if *light == TrafficLight::Red {
        "Stop".as_ref()
    }
    else if *light == TrafficLight::Yellow {
        "Caution".as_ref()
    }
    else {
        "Go".as_ref()
    }
}

abelneo

abel-cod

9 days ago

3.54ms

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", 
    }
}

Lucop1911

9 days ago

3.35ms

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"
    }
}

Rocky.C

cloki0610

9 days ago

4.90ms

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"
    }
}

Tommy

verse215

9 days ago

3.58ms

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",
    }
}

hahu07

10 days ago

3.62ms

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"
     }
}

s.i

ssmi75

11 days ago

2.68ms

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"
    }
}

ikatlinsky

12 days ago

2.96ms

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",
    }
}

zzispp

12 days ago

2.74ms

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",
    }
}

Tim

timvyy

13 days ago

2.76ms

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",
    }
}

diucicd

14 days ago

3.41ms

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",
        _ => "Go",
    }
}

Gabriel Menezes

GMNDS

15 days ago

4.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",
    }
}

esl

esl07

15 days ago

3.14ms

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",
    }
}

HusseinAbdelhamid

16 days ago

3.66ms

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::Green => "Go",
        TrafficLight::Red => "Stop",
        TrafficLight::Yellow => "Caution"
    }
}

Smith Cruise

Smith-Cruise

16 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"
        }
    }
}

ALDebugs

18 days ago

3.21ms

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",
        _ => "",
    }
}

AQian

AQian0

19 days ago

4.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",
    }
}

Torge

tostu

20 days ago

21.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",
    }
}

dunxen

20 days ago

4.61ms

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",
    }
}

GregGorin

22 days ago

3.27ms

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",
    }
}

Francisco Garau

fgarau

22 days ago

2.71ms

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",
    }
}

Sergey Matyash

matiaspub

22 days ago

2.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",
    }
}

ycgw

23 days ago

3.44ms

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",
    }
}

zapp42

23 days ago

3.09ms

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"
    }
}

LeonardoPinheiro23

23 days ago

3.26ms

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",
    }
}

jbrakmic

23 days ago

4.19ms

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",
    }
}

annececiledunand

24 days ago

4.08ms

81.28kb

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

Hendrik Dreesmann

DeemanOne

24 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 => return "Stop",
        TrafficLight::Yellow => return "Caution",
        TrafficLight::Green => return "Go",
    }
}

Saksinkarn Petchkuljinda

dward2nd

24 days ago

4.11ms

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",
    }
}

wry

Liudel

24 days ago

6.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",
    }
}

Anatma2

24 days ago

4.74ms

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",
    }
}

Travis

ttmgraham

25 days ago

7.03ms

81.28kb

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

fomulate

finbaromahony

25 days ago

3.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",
    }
}

Tommytto

25 days ago

2.93ms

81.28kb

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

Erik Hollembeak

futureperfect

25 days ago

3.45ms

81.28kb

pub enum TrafficLight {
    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",
    }
}

AshutoshKumarPatel

a month ago

4.39ms

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"
    }
}