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

Javets70

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

Noxyss

18 hours ago

3.46ms

87.40kb

#[derive(Eq, PartialEq)]
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 {
        // Your code here...
        match self {
            VehicleStatus::Parked => return String::from("The vehicle is parked."),
            VehicleStatus::Driving { speed } => return format!("The vehicle is driving at {} km/h.",speed),
            VehicleStatus::BrokenDown(s) => return format!("The vehicle is broken down: {}.",s)
        }
    }
}
// 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."
    );
}

Harsh Ranjan

harshRn

19 hours ago

5.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 {
            Self::Parked | Self::Driving{speed: _}=> true,
            _ => 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(x) => format!("The vehicle is broken down: {}.", x)
        }
    }
}
// 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."
    );
}

Harsh Ranjan

harshRn

20 hours 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 {
            Self::Parked => true,
            Self::Driving{ speed: _} => true,
            _ => 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(x) => format!("The vehicle is broken down: {}.", x)
        }
    }
}
// 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."
    );
}

Jai

jsat97

a day 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 {
        match self {
            VehicleStatus::Parked => true,
            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(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."
    );
}

bernardoLY19

a day ago

3.26ms

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

Artem Nistuley

artemnistuley

2 days ago

3.59ms

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

noomcreator

2 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 {
        // Your code here...
        match &self {
            VehicleStatus::Parked => true,
            VehicleStatus::Driving{..} => true,
            VehicleStatus::BrokenDown(_reason) => 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."
    );
}

Baron Curtin

baroncurtin2

2 days ago

4.05ms

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 Self::BrokenDown(_) = self {
            return false;
        } 
        true
    }
    pub fn description(&self) -> String {
        match self {
            Self::Parked => String::from("The vehicle is parked."),
            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."
    );
}

Miguel Ángel Allende

maallende

3 days ago

3.74ms

87.40kb

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

xvzhang

xvzhnang

3 days ago

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

Cobran53

4 days ago

3.40ms

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

alexsavio

6 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 {
        match self {
            Self::BrokenDown(_) => false,
            Self::Parked => true,
            Self::Driving{speed: _} => true,
        }
    }
    pub fn description(&self) -> String {
        match self {
            Self::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
            Self::Parked => "The vehicle is parked.".to_string(),
            Self::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."
    );
}

medzernik

8 days ago

3.75ms

87.40kb

pub enum VehicleStatus {
    Parked,
    Driving{speed: u32},
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        if let Self::BrokenDown(_) = self {
            false
        } else {
            true
        }
    }
    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."
    );
}

coreyralph

8 days ago

3.18ms

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

Herman effendi

hrmneffdii

8 days ago

3.54ms

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

Ushakov Andrey

stdstring

10 days ago

3.17ms

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

Philippe Massicotte

PMassicotte

11 days ago

4.17ms

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

CDzungx

11 days ago

3.41ms

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

kcoolio

chrisjude254

11 days ago

4.68ms

87.40kb

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

Camiam144

11 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 {
        // Your code here...
        match &self {
            VehicleStatus::BrokenDown(_rsn) => false,
            _ => true
        }
    }
    pub fn description(&self) -> String {
        // Your code here...
        match &self{
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving{ref speed} => format!{"The vehicle is driving at {speed} km/h."},
            VehicleStatus::BrokenDown(ref 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."
    );
}

vanos001

12 days ago

3.16ms

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...
        return match self {
            VehicleStatus::Parked | VehicleStatus::Driving{ speed : _ } => true,
            VehicleStatus::BrokenDown(_) => false,
        }
    }
    pub fn description(&self) -> String {
        // Your code here...
        return match self {
            VehicleStatus::Parked => "The vehicle is parked.".to_string(),
            VehicleStatus::Driving{ speed : t } => format!("The vehicle is driving at {t} 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."
    );
}

Enes

enesscevik

13 days ago

3.46ms

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

KuuShyn

13 days 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

14 days 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

14 days 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

14 days 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

15 days 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

15 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

15 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

16 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

18 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

18 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

18 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

18 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

20 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

20 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

21 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

21 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

21 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

21 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

23 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

24 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

24 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

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

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

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

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

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

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