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

Eliettetheegeek

an hour ago

4.00ms

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 {
        // 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."
    );
}

khadre07

5 hours ago

5.10ms

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(_reason) => false,
            VehicleStatus::Driving{speed: _} => 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 {} 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."
    );
}

PreppyMiguel

lusuo9

10 hours 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 {
        // Your code here...
        match self {
            VehicleStatus::Parked => true,
            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."
    );
}

PreppyMiguel

lusuo9

10 hours ago

3.73ms

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(_) => 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."
    );
}

vivek

vivek-inavalli

15 hours ago

3.26ms

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 {
        // 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."
    );
}

vivek

vivek-inavalli

15 hours 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::Parked => true,
            VehicleStatus::Driving{..} => 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."
    );
}

Hariom

om-secadvice

2 days ago

4.87ms

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 => "The vehicle is parked.".into(),
            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."
    );
}

DjukicDragan01

4 days ago

3.27ms

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 {
         // 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."
    );
}

DjukicDragan01

4 days 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 {
        match self {
            VehicleStatus::Parked => {true}
            VehicleStatus::Driving{speed} => {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."
    );
}

Özgür

AyikOzgur

4 days ago

3.29ms

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 => {"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."
    );
}

azmahflameheart

4 days ago

3.34ms

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...
        
        // Alternative:
        //matches!(self, Self::Parked | Self::Driving { .. })
        
        /* Another alternative:
        match self {
            Self::Parked | Self::Driving { .. } => true,
            _ => false
        } 
        */
        if let Self::Parked | Self::Driving { .. } = self { true } else { 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 {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."
    );
}

Egu0

egu0

4 days ago

3.20ms

87.43kb

pub enum VehicleStatus {
    Parked,
    Driving { speed: u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
            Self::Parked => true,
            Self::Driving { speed: _ } => true,
            Self::BrokenDown(_) => false,
        }
    }
    pub fn description(&self) -> String {
        match self {
            Self::Parked => "The vehicle is parked.".to_string(),
            Self::Driving { speed } => {
                format!("The vehicle is driving at {speed} km/h.").to_string()
            }
            Self::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."
    );
}

emiludenz

4 days ago

4.12ms

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

Vendra000

4 days ago

3.33ms

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 => format!("The vehicle is parked."),
            VehicleStatus::Driving{speed} => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(r) =>  format!("The vehicle is broken down: {r}.")
        }
    }
}
// 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."
    );
}

LawisChen

6 days ago

3.29ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    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."
    );
}

Alex

ravsii

6 days ago

3.44ms

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.".into(),
            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."
    );
}

Marouan Boulahtouf

MBoulahtouf

6 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::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 {} 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."
    );
}

delxs

7 days ago

3.15ms

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 =>  "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."
    );
}

ffrie

7 days ago

3.46ms

87.43kb

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 {speed} km/h.").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."
    );
}

Ramon Silva

rsilva1

8 days ago

3.24ms

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

Ramon Silva

rsilva1

8 days ago

3.26ms

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

Anthony Young

A-Young-Git

8 days ago

3.27ms

87.40kb

pub struct Parked;
pub struct Driving {
    pub speed: u32,
}
pub struct BrokenDown(pub String);
pub enum VehicleStatus {
    Parked,
    Driving { speed: u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
            Self::Driving { speed: _ } => return true,
            Self::Parked => return true,
            Self::BrokenDown(_) => return false,
        }
    }
    pub fn description(&self) -> String {
        match self {
            Self::Parked => "The vehicle is parked.".to_string(),
            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."
    );
}

something238892

8 days ago

3.14ms

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."
    );
}

Timmy

sha2dow4

9 days ago

3.06ms

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 {
        match self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving{speed: s} => format!("The vehicle is driving at {} km/h.", s),
            VehicleStatus::BrokenDown(r) => format!("The vehicle is broken down: {}.", r),
        }
    }
}
// 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."
    );
}

Snoweuph

snoweuph

10 days ago

3.00ms

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.".into(),
            VehicleStatus::Driving { speed } => format!("The vehicle is driving at {speed} km/h."),
            VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
        }
    }
}

Yonny Sanchez

yonnylsb

10 days ago

3.13ms

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 {} km/h.", speed),
            VehicleStatus::BrokenDown(problem) => format!("The vehicle is broken down: {}.", problem),
        }
    }
}
// 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."
    );
}

ibrahimomar9316

10 days ago

3.18ms

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(_) => return false,
            _ => return 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 {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."
    );
}

ibrahimomar9316

10 days ago

3.60ms

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(_) => return false,
            _ => return 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."
    );
}

Hossein Adib

hosseinadib-hub

10 days ago

3.11ms

87.43kb

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.").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."
    );
}

penmanglewood

10 days ago

3.16ms

87.40kb

pub enum VehicleStatus {
    Parked,
    Driving { speed: u32 },
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
            Self::Parked => true,
            Self::Driving { speed } => true,
            Self::BrokenDown(reason) => false,
        }
    }
    pub fn description(&self) -> String {
        match self {
            Self::Parked => "The vehicle is parked.".into(),
            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."
    );
}

winter

winter-08

10 days ago

3.22ms

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 {} 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."
    );
}

winter

winter-08

10 days ago

2.93ms

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 {} 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."
    );
}

vqk-2003

10 days ago

3.26ms

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."
    );
}

vqk-2003

10 days ago

4.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 { speed: _ } => 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."
    );
}

makinpaper

11 days ago

3.16ms

87.40kb

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 => "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."
    );
}

Rishika Sharma

Rishika-dev

11 days ago

3.95ms

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 {
        match self {
            VehicleStatus::Parked  => "The vehicle is parked.".to_owned(),
            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."
    );
}

Amit Patel

amitpatel-wstf

11 days ago

3.24ms

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 {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."
    );
}

Dan Wayne

danwayne-me

12 days ago

3.29ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving {speed: i32},
    BrokenDown(String),
}
use VehicleStatus::{Parked, Driving, BrokenDown};
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        // Your code here...
        if let BrokenDown(_) = self {
            false
        } else {
            true
        }
    }
    pub fn description(&self) -> String {
        // Your code here...
        match self {
            Parked => "The vehicle is parked.".to_string(),
            Driving {speed} => format!("The vehicle is driving at {speed} km/h."),
            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."
    );
}

fasolyee

fasolyeedev

12 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=>true,
            VehicleStatus::Driving{speed}=>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} =>
                String::from(format!("The vehicle is driving at {} km/h.",speed)),
            VehicleStatus::BrokenDown(reason) =>
                String::from(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."
    );
}

batblerone

13 days ago

3.25ms

87.43kb

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.").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."
    );
}

DebroyeAntoine

13 days ago

3.17ms

87.40kb

pub enum VehicleStatus {
    Parked,
    Driving {speed: u32},
    BrokenDown(String)
    // Define the VehicleStatus variants here
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        match self {
            VehicleStatus::BrokenDown(_) => false,
            _ => true
        }
        // Your code here...
    }
    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}.")
        }
        // Your code here...
    }
}
// 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."
    );
}

fawhizy

fawizzy

14 days ago

4.52ms

87.43kb

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.").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."
    );
}

Sameer

shaiksameer1604

15 days ago

3.97ms

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(_) => return false,
            _ => return 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 {} 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."
    );
}

Roman Lee

Leerv474

15 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::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 {} 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."
    );
}

Retroz

Fungichi

15 days ago

4.35ms

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

Nanda Arta

Nansky

16 days ago

3.85ms

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 {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."
    );
}

gtakacse

16 days ago

3.16ms

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 {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."
    );
}

Shivam Jain

shivam-jainn

17 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...
        match self{
            VehicleStatus::BrokenDown(_) => false,
            _ => true,
        }
    }
    pub fn description(&self) -> String {
        // Your code here...
        return 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."
    );
}

karthick121

17 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 {
        if let VehicleStatus::BrokenDown(_) = self {
            false
        } else {
            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 {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."
    );
}

Erdem Başoğul

erdembasogul

17 days ago

3.31ms

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 {
        // 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."
    );
}