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

michdorf

8 hours ago

4.18ms

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

vojta stefan

vojtastefan

a day ago

3.86ms

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

Pranav Garg

PranavGarg01

2 days ago

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

Hung Dinh

nhdinh

2 days ago

3.37ms

87.40kb

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

AnKarl

Zythophilus

3 days ago

3.67ms

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

amaneru

7ma8no9

3 days ago

3.49ms

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

AKA.MoneyTaker

M4Bo2

5 days ago

3.84ms

87.40kb

// Define the VehicleStatus enum with the specified variants
pub enum VehicleStatus {
    Parked, // Unit variant representing a parked vehicle
    Driving { speed: u32 }, // Named field variant representing a vehicle driving at a certain speed
    BrokenDown(String), // Tuple variant with a String describing the reason for the breakdown
}
// Implement methods for VehicleStatus
impl VehicleStatus {
    // Method to check if the vehicle is operational
    pub fn is_operational(&self) -> bool {
        match self {
            VehicleStatus::Parked | VehicleStatus::Driving { .. } => true, // Vehicle is operational if Parked or Driving
            VehicleStatus::BrokenDown(_) => false, // Vehicle is not operational if BrokenDown
        }
    }
    // Method to return a description of the vehicle's status
    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."
    );
}

Artyom Chebotarev

Derik117

5 days ago

3.99ms

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

Kamuran

karapy

5 days ago

3.56ms

87.43kb

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

zawwwu

5 days ago

3.29ms

87.40kb

pub enum VehicleStatus {
    Parked,
    Driving{speed: u32},
    BrokenDown(String),
}
impl VehicleStatus {
    pub fn is_operational(&self) -> bool {
        matches!(self, VehicleStatus::Parked) || matches!(self, VehicleStatus::Driving{ speed: _ })
    }
    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."
    );
}

Dimas Avrian Fachriza.

FForFachriza

5 days ago

3.28ms

87.40kb

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

Éric Villani

TheTrueCaligari

7 days ago

5.34ms

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

Lê Minh Quân

aleister1102

8 days ago

3.78ms

87.40kb

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

Timothy Z.

kKaskak

9 days ago

2.98ms

87.40kb

use std::format;
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 => 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."
    );
}

Yi Hao

leongyihao

10 days ago

3.15ms

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 => "The vehicle is parked.".to_string(),
			VehicleStatus::BrokenDown(reason) => format!("The vehicle is broken down: {reason}."),
			VehicleStatus::Driving { speed } => format!("The vehicle is driving at {speed} km/h.")
		}
    }
}
// Example use case
pub fn main() {
    let parked = VehicleStatus::Parked;
    assert!(parked.is_operational());
    assert_eq!(parked.description(), "The vehicle is parked.");
    let driving = VehicleStatus::Driving { speed: 80 };
    assert!(driving.is_operational());
    assert_eq!(driving.description(), "The vehicle is driving at 80 km/h.");
    let broken_down = VehicleStatus::BrokenDown("Flat tire".to_string());
    assert!(!broken_down.is_operational());
    assert_eq!(
        broken_down.description(),
        "The vehicle is broken down: Flat tire."
    );
}

Vladimir

PavluninVladimir

11 days ago

3.40ms

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

TiagONTOP

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

Dyaa Adel

dyaa-adel

11 days ago

3.56ms

87.40kb

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

Anıl Şenay

anilsenay

11 days ago

9.69ms

87.40kb

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

Ayushman Rathore

Spartan09

11 days ago

4.21ms

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

Guilherme Cesário Strachan

strachan

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

norabbito

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

norabbito

11 days ago

3.42ms

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

Christopher Kolbe

chkolbe

12 days ago

3.57ms

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

Jordan

Jordan-Haidee

13 days ago

3.53ms

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

Kyle Diaz

kylediaz

15 days ago

3.28ms

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

McToady.eth

McCoady

16 days ago

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

Kenneth Love

kennethlove

16 days ago

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

Prafful

iamsahu

17 days ago

17.63ms

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

Benjamin Falk

lumio

17 days ago

3.06ms

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

Douglas Campbell

CampbellD84

18 days ago

3.25ms

87.40kb

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

Douglas Campbell

CampbellD84

18 days ago

3.17ms

87.40kb

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

ludovicknecht

18 days ago

3.78ms

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

Whisper_icoma

1378046967

19 days ago

7.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 {
            Self::Parked | Self::Driving{speed: _} => true,
            Self::BrokenDown(_) => 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(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."
    );
}

Muhammad-Dennis

19 days ago

3.38ms

87.40kb

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

Diego Maia

diegocmsantos

19 days ago

3.83ms

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

manuelmj

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

automata-studio

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

kosay

sarub0b0

20 days ago

4.37ms

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

Denis SOURON

Brack0

20 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::Driving { .. } | VehicleStatus::Parked => 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}."),
        }
    }
}

Donald Huber-Youmans

dHuberYoumans

21 days ago

3.52ms

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

alemack17

21 days ago

3.53ms

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

TeDeMos

22 days ago

4.56ms

87.40kb

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

Nikita Smirnov

Nismirno

22 days ago

6.38ms

87.40kb

pub enum VehicleStatus {
    // Define the VehicleStatus variants here
    Parked,
    Driving { speed: i32 },
    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 {} 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."
    );
}

Joe Schneider

josschne

22 days ago

3.56ms

87.40kb

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

RiyadDz22

22 days ago

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

Jun Huang

leemars

22 days ago

3.60ms

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

Viktor Merkurev

fennr

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

Viktor Merkurev

fennr

23 days ago

4.19ms

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

iamforgettable

23 days ago

3.47ms

87.40kb

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