Methods on Enums

Enums in Rust can have associated functions and methods, just like structs. These methods make it easier to encapsulate behavior directly within the enum.

In this challenge, you'll model the statuses of different vehicles and implement methods to describe their behavior.

Your Task

Create an enum VehicleStatus with the following variants:

Parked — a unit variant representing a parked vehicle.
Driving { speed: u32 } — a named field variant representing a vehicle driving at a certain speed.
BrokenDown(String) — a tuple variant with a String describing the reason for the breakdown.

Implement the following methods for VehicleStatus:

is_operational(&self) -> bool:
- Returns true if the vehicle is either Parked or Driving.
- Returns false if the vehicle is BrokenDown.
description(&self) -> String:
- Returns "The vehicle is parked." for Parked.
- Returns "The vehicle is driving at {speed} km/h." for Driving { speed }.
- Returns "The vehicle is broken down: {reason}." for BrokenDown(reason).

Hints

Click here to reveal hints

Use a match expression inside the methods to handle each variant.
Remember to use &self for the methods since they should not consume the enum.
Use format! to construct strings with dynamic values, such as speed and reason.

Editor not available on Mobile!

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

Solutions

KuuShyn

a minute ago

27.30ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving { speed: u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        match self {
            VehicleStatus::Parked | VehicleStatus::Driving { .. } => true,
            _ => false,
        }
    }
    pub fn description(&self) -> String {
        // Your code here...
        match &self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving { speed } => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Smith Cruise

Smith-Cruise

16 hours ago

3.45ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving{speed: u32},
    BrokenDown(String)
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        match self {
            VehicleStatus::Parked => true,
            VehicleStatus::BrokenDown(_) => false,
            _ => true
        }
    }
    pub fn description(&self) -> String {
        // Your code here...
        match self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving{speed} => format!("The vehicle is driving at {} km/h.", speed),
            VehicleStatus::BrokenDown(v) => format!("The vehicle is broken down: {}.", v)
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Kr0wZ

16 hours ago

3.58ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving { speed: u32},
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        if let Self::Parked | Self::Driving{ .. } = self {
            return true;
        }
        false
        /*if let Self::BrokenDown(_string) = self {
            return false;
        }
        else {
            return true;
        }*/
        
        /*match self {
            Self::Parked => return true,
            Self::Driving{speed} => return true,
            _ => return false,
        }*/
    }
    pub fn description(&self) -> String {
        // Your code here...
        match self {
            Self::Parked => String::from("The vehicle is parked."),
            Self::Driving { speed } => format!("The vehicle is driving at {speed} km/h."),
            Self::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Luigi Terrone

LuigiTer

20 hours ago

3.65ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving { speed: u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        match self {
            VehicleStatus::Parked | VehicleStatus::Driving { .. } => true,
            _ => false
        }
    }
    pub fn description(&self) -> String {
        // Your code here...
         match self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving{speed} => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Karol Płatkowski

spoohie

a day ago

3.72ms

87.43kb

pub enum VehicleStatus {
    Parked,
    Driving {speed: u32},
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        !matches!(self, VehicleStatus::BrokenDown(_))
    }
    pub fn description(&self) -> String {
        return format!("The vehicle is {}.", self.unwrap_desc())
    }
    pub fn unwrap_desc(&self) -> String {
        match &self {
            VehicleStatus::Parked => "parked".to_string(),
            VehicleStatus::Driving {speed} => format!("driving at {speed} km/h"),
            VehicleStatus::BrokenDown(cause) => format!("broken down: {cause}"),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Heino Mortensen

hmortensen83

2 days ago

3.18ms

87.40kb

pub enum VehicleStatus {
    Parked,
    Driving { speed: u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        !matches!(self, VehicleStatus::BrokenDown(_))
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving { speed } => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

0x0f1

Paul4673

2 days ago

3.10ms

87.40kb

pub enum VehicleStatus {
    Parked, Driving { speed : u32 }, BrokenDown(String)
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
            VehicleStatus::Parked => true,
            VehicleStatus::Driving{speed : _} => true,
            VehicleStatus::BrokenDown( _reason ) => false,
        }
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::Parked => format!("The vehicle is parked."),
            VehicleStatus::Driving{speed} => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

dattruongdev

3 days ago

3.23ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving {speed: u32},
    BrokenDown(String)
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        match self {
            VehicleStatus::BrokenDown(_) => false,
            _ => true,
        }
    }
    pub fn description(&self) -> String {
        // Your code here...
        match self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving {speed} => format!("The vehicle is driving at {} km/h.", speed),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {}.", reason),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

silaskoemen

4 days ago

3.13ms

87.40kb

pub enum VehicleStatus {
    Parked,
    Driving { speed: u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
            VehicleStatus::Parked | VehicleStatus::Driving{..} => true,
            _ => false,
        }
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving{speed} => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Sarthak Mishra

sithtsar

5 days ago

3.22ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving{speed : u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        let op = match self{
            VehicleStatus::Parked => true,
            VehicleStatus::Driving{speed} => true, 
            VehicleStatus::BrokenDown(reason) =>false, 
        };
        op
    }
    pub fn description(&self) -> String {
        // Your code here...
        let des = match self{
            VehicleStatus::Parked =>format!("The vehicle is parked."),
            VehicleStatus::Driving{speed} => format!("The vehicle is driving at {} km/h.",speed), 
            VehicleStatus::BrokenDown(reason) =>format!("The vehicle is broken down: {}.",reason), 
        };
       des  
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Tri Nguyen

nguyentri

5 days ago

3.26ms

87.40kb

#[derive(Debug, Clone)]
pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving { 
        speed: u32
    },
    BrokenDown (String),
}
impl VehicleStatus {
    #[allow(unused)]
    fn get_speed (&self) -> Option<u32> {
        if let VehicleStatus::Driving {speed} = self {
            Some(*speed)
        } else {
            None
        }
    }
    pub fn is_operational(&self) -> bool {
        if let VehicleStatus::BrokenDown(..) = self {
            false
        } else {
            true
        }
    }
    pub fn description(&self) -> String {
        // Your code here... 
        match self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving {speed} =>  format!("The vehicle is driving at {} km/h.", *speed),
            VehicleStatus::BrokenDown (desc) => format!("The vehicle is broken down: {}.", desc),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Tri Nguyen

nguyentri

5 days ago

3.47ms

87.40kb

#[derive(Debug, Clone)]
pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving { 
        speed: u32
    },
    BrokenDown (String),
}
impl VehicleStatus {
    fn get_speed (&self) -> Option<u32> {
        if let VehicleStatus::Driving {speed} = self {
            Some(*speed)
        } else {
            None
        }
    }
    pub fn is_operational(&self) -> bool {
        if let VehicleStatus::BrokenDown(..) = self {
            false
        } else {
            true
        }
    }
    pub fn description(&self) -> String {
        // Your code here... 
        match self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving {speed:_} => {
                match self.get_speed() {
                    Some(speed) => format!("The vehicle is driving at {} km/h.", speed),
                    None => format!("The vehicle is not driving."),
                }
            },
            VehicleStatus::BrokenDown (desc) => format!("The vehicle is broken down: {}.", desc),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

xxxxsk

7 days ago

3.44ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving {speed: u32},
    BrokenDown(String)
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        match self {
            VehicleStatus::Parked | VehicleStatus::Driving {..} => true,
            _ => false
        }
    }
    pub fn description(&self) -> String {
        // Your code here...
        match self { 
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving {speed} => format!("The vehicle is driving at {} km/h.", speed),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {}.", reason)
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Rocky.C

cloki0610

7 days ago

3.68ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving { speed: u32 },
    BrokenDown(String)
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        match self {
            VehicleStatus::Parked | VehicleStatus::Driving{..} => true,
            VehicleStatus::BrokenDown(_) => false
        }
    }
    pub fn description(&self) -> String {
        // Your code here...
        match self {
            VehicleStatus::Parked => String::from("The vehicle is parked."),
            VehicleStatus::Driving{speed} => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}.")
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Pierre Gordo

PierreGordo

8 days ago

4.02ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving {speed: u32},
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        match &self{
            VehicleStatus::Parked => true,
            VehicleStatus::Driving{speed: _} => true,
            VehicleStatus::BrokenDown(_reason) => false,
        }
    }
    pub fn description(&self) -> String {
        // Your code here...
        match &self{          
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving{speed} => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Satya Sundar Sahu

satya200

8 days ago

3.62ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving { speed: u32 },
    BrokenDown(String)
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        match self {
            VehicleStatus::BrokenDown(_) => false,
            _ => true
        }
    }
    pub fn description(&self) -> String {
        // Your code here...
        match self {
            VehicleStatus::Parked => format!("The vehicle is parked."),
            VehicleStatus::Driving { speed } => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}.")
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Gomathi Shankar

gomathishankar37

8 days ago

4.00ms

87.40kb

pub enum VehicleStatus {
    Parked,
    Driving {speed: u32},
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
            VehicleStatus::BrokenDown(_) => false,
            _ => true,
        }
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::Parked => String::from("The vehicle is parked."),
            VehicleStatus::Driving {speed} => format!("The vehicle is driving at {} km/h.", speed),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {}.", reason),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Lucop1911

8 days ago

5.91ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving {speed: u32},
    BrokenDown(String)
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        match self {
            VehicleStatus::Parked | VehicleStatus::Driving{ speed: _ } => true,
            VehicleStatus::BrokenDown(_) => false
        }
    }
    pub fn description(&self) -> String {
        // Your code here...
        match self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving{speed} => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

hahu07

10 days ago

5.38ms

87.40kb

pub enum VehicleStatus {
    Parked,
    Driving {speed: u32},
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
            VehicleStatus::Parked | VehicleStatus::Driving{speed: _} => true,
            VehicleStatus::BrokenDown(_) => false,
        }
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::Parked => String::from("The vehicle is parked."),
            VehicleStatus::Driving{speed} => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

s.i

ssmi75

11 days ago

3.96ms

87.40kb

pub enum VehicleStatus {
    Parked,
    Driving {speed: u32},
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
            VehicleStatus::Parked | VehicleStatus::Driving{speed: _} => true,
            VehicleStatus::BrokenDown(_) => false,
        }
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::Parked => String::from("The vehicle is parked."),
            VehicleStatus::Driving{speed} => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

ikatlinsky

11 days ago

4.91ms

87.40kb

#[derive(Eq, PartialEq)]
pub enum VehicleStatus {
    Parked,
    Driving { speed: u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        matches!(self, VehicleStatus::Parked | VehicleStatus::Driving{..})
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::Parked => String::from("The vehicle is parked."),
            VehicleStatus::Driving { speed } => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}.")
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Tim

timvyy

13 days ago

3.08ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving { speed: u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        if let VehicleStatus::BrokenDown(_) = self {
            false
        } else {
            true
        }
    }
    pub fn description(&self) -> String {
        // Your code here...
        match self {
            VehicleStatus::Parked => String::from("The vehicle is parked."),
            VehicleStatus::Driving { speed } => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

diucicd

14 days ago

3.70ms

87.40kb

pub enum VehicleStatus {
    Parked,
    Driving { speed: u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        !matches!(self, VehicleStatus::BrokenDown(_))
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving { speed } => {
                format!("The vehicle is driving at {} km/h.", speed)
            }
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {}.", reason),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Gabriel Menezes

GMNDS

14 days ago

3.98ms

87.40kb

pub enum VehicleStatus {
    Parked,
    Driving {speed: u32},
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
       match self {
        VehicleStatus::BrokenDown(_) => false,
        _ => true,
       }
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving {speed} => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}.")
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

HusseinAbdelhamid

15 days ago

3.12ms

87.40kb

#[derive(PartialEq)]
pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving{speed: u32},
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        match self{
            Self::BrokenDown(_) => false,
            _ =>true,
        }
    }
    pub fn description(&self) -> String {
        // Your code here...
        match self{
            Self::Parked => format!("The vehicle is parked."),
            Self::Driving{speed} => format!("The vehicle is driving at {speed} km/h."),
            Self::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

esl

esl07

15 days ago

3.40ms

87.40kb

pub enum VehicleStatus {
    Parked,
    Driving { speed: u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
            VehicleStatus::Parked => true,
            VehicleStatus::Driving { speed: _ } => true,
            VehicleStatus::BrokenDown(_) => false,
        }
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving { speed } => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

0x90

riccio8

17 days ago

9.08ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving { speed: u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self{
            VehicleStatus::Parked => true,
            VehicleStatus::Driving{..} => true,
            _=> false,
        }   
    }
    pub fn description(&self) -> String {
        match self{
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving{speed} => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(rea) => format!("The vehicle is broken down: {rea}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

AQian

AQian0

18 days ago

5.14ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving {
        speed: u32,
    },
    BrokenDown (String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        if let VehicleStatus::BrokenDown(_) = self {
            return false
        }
        return true
    }
    pub fn description(&self) -> String {
        // Your code here...
        match self {
            VehicleStatus::Parked => format!("The vehicle is parked."),
            VehicleStatus::Driving { speed } => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown (reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

ALDebugs

18 days ago

3.30ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving { speed: u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
            VehicleStatus::Parked | VehicleStatus::Driving {..} => true,
            VehicleStatus::BrokenDown(_) => false,
        }
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving { speed } => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
            _ => "".to_string(),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

annececiledunand

19 days ago

3.29ms

87.40kb

pub enum VehicleStatus {
    Parked,
    Driving { speed: u32 },
    BrokenDown (String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
            VehicleStatus::BrokenDown(_) => false,
            _ => true,
        }
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving { speed } => format!("The vehicle is driving at {speed} km/h."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

annececiledunand

19 days ago

4.08ms

87.43kb

pub enum VehicleStatus {
    Parked,
    Driving { speed: u32 },
    BrokenDown (String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
            VehicleStatus::BrokenDown(_) => false,
            _ => true,
        }
    }
    pub fn description(&self) -> String {
        let tail: String = match self {
            VehicleStatus::BrokenDown(reason) => "broken down: ".to_string() + reason,
            VehicleStatus::Parked => "parked".to_string(),
            VehicleStatus::Driving { speed } => format!("driving at {speed} km/h"),
        };
        "The vehicle is ".to_string() + &tail + "."
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Sergey Matyash

matiaspub

20 days ago

3.21ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving{ speed: u32 },
    BrokenDown(String)
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        match self {
            VehicleStatus::BrokenDown(..) => false,
            _ => true,
        }
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving{speed} => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

GregGorin

21 days ago

3.07ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked ,
    Driving { speed: u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
           VehicleStatus::BrokenDown(_) => false,
           _ => true, 
        }
    }
    pub fn description(&self) -> String {
        match self {
           VehicleStatus::Parked => format!("The vehicle is parked."),
           VehicleStatus::Driving{speed} => format!("The vehicle is driving at {speed} km/h."),
           VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Francisco Garau

fgarau

22 days ago

3.54ms

87.40kb

pub enum VehicleStatus {
    Parked, 
    Driving {speed: u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
            Self::BrokenDown(_) => false,
            _ => true
        }
    }
    pub fn description(&self) -> String {
        match self {
            Self::Parked => format!("The vehicle is parked."),
            Self::Driving {speed} => format!("The vehicle is driving at {speed} km/h."),
            Self::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Hendrik Dreesmann

DeemanOne

22 days ago

4.33ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving { speed: u32},
    BrokenDown(String)
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        
        // Your code here...
        match self 
        {
            VehicleStatus::Parked => true,
             VehicleStatus::Driving{speed} => true, 
            VehicleStatus::BrokenDown(reason) => false
        }
    }
    pub fn description(&self) -> String {
        // Your code here...
        match self {
            VehicleStatus::Parked => return format!("The vehicle is parked."),
            VehicleStatus::Driving {speed} => return format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => return format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

zapp42

23 days ago

3.57ms

87.40kb

pub enum VehicleStatus {
    Parked,
    Driving { speed: u32 },
    BrokenDown(String)
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
            VehicleStatus::BrokenDown(..) => false,
            _ => true
        }
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::Parked => String::from("The vehicle is parked."),
            VehicleStatus::Driving { speed } => format!("The vehicle is driving at {} km/h.", speed),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {}.", reason)
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

ycgw

23 days ago

4.01ms

87.40kb

pub enum VehicleStatus {
    Parked,
    Driving { speed: u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
            VehicleStatus::Parked => true,
            VehicleStatus::Driving { speed: _ } => true,
            VehicleStatus::BrokenDown(_) => false,
        }
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::Parked => String::from("The vehicle is parked."),
            VehicleStatus::Driving { speed } => {
                format!("The vehicle is driving at {} km/h.", speed)
            }
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {}.", reason),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

LeonardoPinheiro23

23 days ago

4.98ms

87.40kb

pub enum VehicleStatus {
    Parked,
    Driving { speed: u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        !matches!(self, VehicleStatus::BrokenDown(_))
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::Parked => String::from("The vehicle is parked."),
            VehicleStatus::Driving { speed } => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

jbrakmic

23 days ago

4.94ms

87.40kb

pub enum VehicleStatus {
    Parked,
    Driving {
        speed: u32,
    },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
            VehicleStatus::Parked |
            VehicleStatus::Driving{..} => true,
            VehicleStatus::BrokenDown(_) => false,
        }
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving{speed} => format!("The vehicle is driving at {} km/h.", speed),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {}.", reason),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Saksinkarn Petchkuljinda

dward2nd

24 days ago

4.56ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving { speed: u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        match self {
            Self::BrokenDown(_) => false,
            _ => true,
        }
    }
    pub fn description(&self) -> String {
        // Your code here...
        match self {
            Self::Parked => "The vehicle is parked.".to_string(),
            Self::Driving { speed } => {
                format!("The vehicle is driving at {} km/h.", speed)
            },
            Self::BrokenDown(reason) => {
                format!("The vehicle is broken down: {}.", reason)
            }
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

wry

Liudel

24 days ago

8.14ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving { speed: u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        match self {
            Self::Parked => true,
            Self::Driving { speed } => true,
            Self::BrokenDown(d) => false,
        }
    }
    pub fn description(&self) -> String {
        // Your code here...
        match self {
            Self::Parked => "The vehicle is parked.".to_string(),
            Self::Driving { speed } => format!("The vehicle is driving at {} km/h.", speed),
            Self::BrokenDown(c) => format!("The vehicle is broken down: {}.", c),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Anatma2

24 days ago

3.72ms

87.43kb

pub enum VehicleStatus 
{
    Parked,
    Driving{speed:u32},
    BrokenDown(String),
}
impl VehicleStatus 
{
    pub fn is_operational(&self) -> bool 
    {
        match self
        {
            VehicleStatus::Parked => true,
            VehicleStatus::Driving{speed} => true,
            VehicleStatus::BrokenDown(_) => false
        }
    }
    pub fn description(&self) -> String 
    {
        match self 
        {
            VehicleStatus::Parked => ("The vehicle is parked.").to_string(),
            VehicleStatus::Driving{speed} => format!("The vehicle is driving at {} km/h.", speed).to_string(),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {}.", reason).to_string(),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Travis

ttmgraham

25 days ago

7.14ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving { speed: u32 },
    BrokenDown(String)
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
            VehicleStatus::Parked => true,
            VehicleStatus::Driving { speed: _ } => true,
            VehicleStatus::BrokenDown(_reason) => false
        }
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving { speed } => format!("The vehicle is driving at {} km/h.", speed),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {}.", reason)
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Tommytto

25 days ago

4.69ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving { speed: u32 },
    BrokenDown(String)
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        match self {
            VehicleStatus::Parked => true,
            VehicleStatus::Driving {..} => true,
            VehicleStatus::BrokenDown(_) => false
        }
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving {speed} => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}.")
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Erik Hollembeak

futureperfect

25 days ago

5.38ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving { speed: u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
            VehicleStatus::BrokenDown(_) => false,
            _ => true,
        }
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving { speed } => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Erik Hollembeak

futureperfect

25 days ago

3.78ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving { speed: u32},
    BrokenDown(String)
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
            VehicleStatus::Parked => true,
            VehicleStatus::Driving { speed: _ } => true,
            VehicleStatus::BrokenDown(_) => false,
        }
    }
    pub fn description(&self) -> String {
        match self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving { speed } => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

AshutoshKumarPatel

a month ago

3.22ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked, Driving {speed: u32}, BrokenDown(String)
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        match self {
            VehicleStatus::Parked => true,
            VehicleStatus::Driving {speed:_} => true,
            _ => false
        }
    }
    pub fn description(&self) -> String {
        // Your code here...
        match self{
            VehicleStatus::Parked => {
                format!("The vehicle is parked.")
            }
            VehicleStatus::Driving {speed} =>{
                format!("The vehicle is driving at {} km/h.",speed)
            }
            VehicleStatus::BrokenDown (reason) =>{
                format!("The vehicle is broken down: {}.",reason)
            }
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Ajit Kumar

urwithajit9

a month ago

4.71ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving {speed:u32},
    BrokenDown(String)
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
       
        match self {
            VehicleStatus::Parked  => true,
            VehicleStatus::Driving {speed:_} => true,
            _ => false
        }
    }
    pub fn description(&self) -> String {
        match self{
            VehicleStatus::Parked => {
                format!("The vehicle is parked.")
            }
            VehicleStatus::Driving {speed} =>{
                format!("The vehicle is driving at {} km/h.",speed)
            }
            VehicleStatus::BrokenDown (reason) =>{
                format!("The vehicle is broken down: {}.",reason)
            }
        }
        
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Maicon Crespo

maiconcrespo

a month ago

3.25ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants hereç
    Parked,
    Driving{speed:u32},
    BrokenDown(String)
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        !matches!(self, VehicleStatus::BrokenDown(_))
    }
    pub fn description(&self) -> String {
        match self{
            VehicleStatus::Parked=>format!("The vehicle is parked."),
            VehicleStatus::Driving{speed}=>format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason)=>format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

sjmellor

a month ago

5.68ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving { speed : u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        match self {
            VehicleStatus::BrokenDown(_) => false,
            _ => true,
        }
    }
    pub fn description(&self) -> String {
        // Your code here...
        match self {
            VehicleStatus::Parked => String::from("The vehicle is parked."),
            VehicleStatus::Driving { speed } => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}