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

Leo

leyonh

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

JesAlbLop

JesAlblop

8 hours ago

3.43ms

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

Octavian

orouwk

21 hours ago

4.02ms

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

anhdoo

TuanAnhDoHoang

3 days ago

3.31ms

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";}
        _ => {return ""}
    }
}

Stas

nevmstas

5 days ago

3.25ms

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

Tristan Young

DragonBeast829

7 days ago

3.20ms

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

Wenceslas E. Jonah

WencesJ

7 days ago

3.62ms

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

Teimur Gasanov

teimurjan

7 days ago

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

Gurneet singh

GS-Jatt

7 days ago

3.92ms

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

Kanak Shilledar

kanakshilledar

8 days ago

3.19ms

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

zazapalm3012

10 days ago

4.00ms

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

AymericRT

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

LLukeDB

11 days ago

3.72ms

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

Health-Care-Movie

12 days ago

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

Thomastienn

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

Elizabeth Doughty

Thymelizabeth

13 days ago

4.20ms

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

Splatrac

splatrac

13 days ago

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

Trịnh Chấn Duy

Duyyy123

16 days ago

3.20ms

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

Nicolai

Posmac

16 days ago

4.95ms

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

Najib-Kassab

18 days ago

3.13ms

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

Liyqq

19 days ago

2.82ms

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

cyberspace lee

cyberspacelee

19 days ago

2.98ms

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

adamegao

21 days ago

3.02ms

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

agamaontherock

23 days ago

3.09ms

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

Neel Knight

NeelKnight

a month ago

3.20ms

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

TestingPurpose14

a month ago

3.85ms

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

Nathan GAUD

Natchica

a month ago

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

mishbah

a month ago

3.46ms

81.28kb

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

Felix Kiprotich

penscola

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

torbenhardt

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

RASHMOR

RASHMOR1

a month ago

2.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",       // This is a string literal, which has a `'static` lifetime
        TrafficLight::Yellow => "Caution", // This is also a string literal with a `'static` lifetime
        TrafficLight::Green => "Go",       // Again, a string literal
    
    }
}

Anderson

Anderon-hk

a month ago

3.25ms

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

Deepanshu Mishra

DeepanshuMishraa

a month ago

2.90ms

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

Pycub

pycub

a month ago

3.15ms

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

Jakub Wiśniewski

wisniewskij

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

Dante Kelly

dantekelly

a month ago

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

Paolo Cancedda

Pac72

a month ago

3.26ms

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

Maintain

duonghb53

a month ago

3.71ms

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

Jason

Jason-fy-wang

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

Nguyen Vo Hoang Son

sonmessia

a month ago

3.36ms

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

Nhat Vu

NhatTinyVu

a month ago

3.84ms

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

Leo Phạm

HongThaiPham

a month ago

7.12ms

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

pop_eax

pop-eax

a month ago

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

Nhat Vu

NhatTinyVu

a month ago

3.20ms

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

vijayabhaskar badireddi

ptcte

a month ago

2.97ms

81.28kb

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

Seth Wood

seth-wood

a month ago

3.45ms

81.28kb

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

Levio-z

a month ago

3.50ms

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

Max

maxemontio

a month ago

3.05ms

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

Ed Longbottom

edlongbottom

a month ago

4.62ms

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

EduardoFernandess

a month ago

5.02ms

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