Day 20: Know Your Status

“IS THE SLEIGH PARKED, READY, OR FLYING? WHY DOESN’T ANYONE KNOW?”

“Uh… shouldn’t you know? Didn't we use the type state pattern?” Bernard spoke up.

Santa's face twitched. "Of course, we used the type state pattern! But does anyone have a quick way to check the state right now? There are some sleighs in the air, it's hard to keep track on all of them."

Blitzen, lounging in a corner, snorted. “Sounds like y'all need to add a status() method.”

Prancer’s ears perked up. “Yeah! A single method we can call to figure out the state, no matter which one it’s in.”

Santa stroked his beard, muttering. “Fine. Add it. And make sure it’s compile-time safe. If I get a wrong answer, someone’s spending Christmas hand-delivering packets in binary.”

Your Mission

It's time to give Santa what he wants: a single status() method that works in all states of the sleigh (Empty, Ready, and Flying), returning the current state as a string.

Here's the plan:

Define the status() method: It should be callable on the Sleigh regardless of its state.
Return a string indicating the sleigh’s state:
- "Empty" when the sleigh is empty.
- "Ready" when the sleigh is loaded and ready to fly.
- "Flying" when the sleigh is in the air.
The Sleigh struct should have a trait bound, not just a generic <T>.

Here's how Santa wants to the the API:

let sleigh = Sleigh::new();
assert_eq!(sleigh.status(), "Empty");
 
sleigh.load();
assert_eq!(sleigh.status(), "Ready");
 
sleigh.take_off();
assert_eq!(sleigh.status(), "Flying");

Hints

If you’re unsure where to start, take a look at these tips:

Click to reveal hints!

Use a trait to define shared behavior across all states. For example:
```
pub trait State {
    fn status() -> &'static str;
}
```

Implement the trait for each state. e.g.

impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}

Implement a method for all types that implement the State trait. e.g.

impl<T: State> Sleigh<T> {
  pub fn status(&self) -> &'static str {
      T::status()
  }
}

Editor not available on Mobile!

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

Solutions

Prashant Puri

Prashant-dot1

5 days ago

1387.21ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait State {
    fn status() -> &'static str;
}
pub struct Sleigh<T> where T : State {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
// Add status method for all states
impl<T> Sleigh<T>
where T: State
{
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

Heino Mortensen

hmortensen83

12 days ago

1390.32ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait State {
    fn status() -> &'static str;
}
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

Andreas Lundin

andreaslundin47

14 days ago

1194.30ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

Spheniscine

18 days ago

1231.80ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}

palcoo42

19 days ago

1194.64ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait State {
    fn status() -> &'static str;
}
pub struct Sleigh<T>
where
    T: State,
{
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl<T> Sleigh<T>
where
    T: State,
{
    pub fn status(&self) -> &str {
        T::status()
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}

visanr

20 days ago

1261.67ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub struct Sleigh<T: Status> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
pub trait Status {
    fn status() -> &'static str;
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Status for Flying {
    fn status() -> &'static str { "Flying" }
}
impl Status for Empty {
    fn status() -> &'static str { "Empty" }
}
impl Status for Ready {
    fn status() -> &'static str { "Ready" }
}
impl<T: Status> Sleigh<T> {
    pub fn status(&self) -> &'static str { T::status() }
}

angalar

21 days ago

1189.84ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub trait State {
    fn status() -> &'static str;
}
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}

gustavLindqvist

21 days ago

1419.03ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub struct Sleigh<T: State> {
    pub state: PhantomData<T>,
}
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

Wouter

WouterMartens

22 days ago

1324.99ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub struct Sleigh<T: State> {
    pub state: PhantomData<T>,
}
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

johndoe30bc

23 days ago

1332.10ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
pub struct Sleigh<T>
where
    T: State,
{
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl<T> Sleigh<T>
where
    T: State,
{
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_status() {
        let sleigh = Sleigh::new();
        assert_eq!(sleigh.status(), "Empty");
        let sleigh = sleigh.load();
        assert_eq!(sleigh.status(), "Ready");
        let sleigh = sleigh.take_off();
        assert_eq!(sleigh.status(), "Flying");
    }
}

tdoan

a month ago

1270.32ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

Chloe

chloecat34

a month ago

1233.47ms

94.55kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
// TODO: Define the `status` method for all states
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

Chloe

chloecat34

a month ago

1207.14ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub trait State {}
impl State for Empty {}
impl State for Ready {}
impl State for Flying {}
// TODO: Define the `status` method for all states
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
    pub fn status(&self) -> String {
        String::from("Empty")
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
    pub fn status(&self) -> String {
        String::from("Ready")
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
    pub fn status(&self) -> String {
        String::from("Flying")
    }
}

brucecox01

a month ago

1240.86ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
pub trait State {
    fn status() -> &'static str;
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}

Philippe Massicotte

PMassicotte

a month ago

1379.47ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub struct Sleigh<T>
where
    T: State,
{
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
pub trait State {
    fn status() -> &'static str;
}
macro_rules! impl_state {
    ($($state:ident),+) => {
        $(
            impl State for $state {
                fn status() -> &'static str {
                    stringify!($state)
                }
            }
        )+
    };
}
impl_state!(Empty, Ready, Flying);
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

Felix

FelixMaetzler

2 months ago

1251.21ms

100.76kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait Status {
    fn status(&self) -> &'static str;
}
impl Status for Empty {
    fn status(&self) -> &'static str {
        "Empty"
    }
}
impl Status for Ready {
    fn status(&self) -> &'static str {
        "Ready"
    }
}
impl Status for Flying {
    fn status(&self) -> &'static str {
        "Flying"
    }
}
pub struct Sleigh<T: Status> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: T,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: Empty }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: Ready }
    }
    pub fn status(&self) -> &'static str {
        self.state.status()
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: Flying }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: Empty }
    }
    pub fn status(&self) -> &'static str {
        self.state.status()
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: Ready }
    }
    pub fn status(&self) -> &'static str {
        self.state.status()
    }
}
fn main() {}

UncleScientist

2 months ago

1254.35ms

93.78kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait Status {
    fn status() -> &'static str;
}
macro_rules! sleigh_status {
    ($($state:ident),+) => {
        $(
        impl Status for $state {
            fn status() -> &'static str {
                stringify!($state)
            }
        })*
    };
}
sleigh_status!(Empty, Ready, Flying);
pub struct Sleigh<T: Status> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl<T: Status> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

AncientSecrets

2 months ago

1241.74ms

94.10kb

pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait State { fn show(&self) -> &str; }
impl State for Empty { fn show(&self) -> &str { "Empty" } }
impl State for Ready { fn show(&self) -> &str { "Ready" } }
impl State for Flying { fn show(&self) -> &str { "Flying" } }
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: T,
}
impl<T: State> Sleigh<T> { pub fn status(&self) -> &str { self.state.show() } }
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: Empty }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: Ready }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: Flying }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: Empty }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: Ready }
    }
}

HubertBL47

2 months ago

1175.06ms

94.29kb

// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
use std::marker::PhantomData;
pub trait State {
    const STATUS: &'static str;
}
pub struct Empty;
impl State for Empty {
    const STATUS: &'static str = "Empty";
}
pub struct Ready;
impl State for Ready {
    const STATUS: &'static str = "Ready";
}
pub struct Flying;
impl State for Flying {
    const STATUS: &'static str = "Flying";
}
// 2. Finish the Seligh struct definition
pub struct Sleigh<S: State> {
    state: PhantomData<S>,
}
impl<S: State> Sleigh<S> {
    pub fn status(&self) -> &str {
        S::STATUS
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Sleigh { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

Kristupas Arifovas

Quikmove

2 months ago

1225.09ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait State {
     fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

xian ma

xanvcs

2 months ago

1263.15ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

zeitnut

2 months ago

1335.01ms

94.10kb

pub struct Empty;
pub struct Ready;
pub struct Flying;
// States should know their own names
pub trait NamedState {
    // fn get_name(&self) -> String;
    // Better (after checking the hints) - NamedState structs don't need to be instantiated to report their names
    fn get_name() -> String;
}
impl NamedState for Empty {
    // fn get_name(&self) -> String {
    fn get_name() -> String {
        "Empty".to_string()
    }
}
impl NamedState for Ready {
    // fn get_name(&self) -> String {
    fn get_name() -> String {
        "Ready".to_string()
    }
}
impl NamedState for Flying {
    // fn get_name(&self) -> String {
    fn get_name() -> String {
        "Flying".to_string()
    }
}
pub struct Sleigh<T: NamedState> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: T,
}
// If we want to restrict T to a subset of types, can group those types using a trait
// There's no way to do <T: Empty || Ready || Flying>
impl<T: NamedState> Sleigh<T>{
    pub fn status(&self) -> String {
        // self.state.get_name()
        T::get_name()
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: Empty }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: Ready }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: Flying }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: Empty }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: Ready }
    }
}

hoslo

2 months ago

1364.40ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait State {
    fn status() -> &'static str;
}
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}

DFC-Siege

2 months ago

1380.67ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait State {
    fn status() -> &'static str;
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

yuiidev

2 months ago

1476.40ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
// TODO: Define the `status` method for all states
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl <T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

diucicd

3 months ago

1335.39ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
//
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

diucicd

3 months ago

1239.63ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
//
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

Pumkko

3 months ago

1395.64ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

Erik Hollembeak

futureperfect

3 months ago

1344.70ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

deo2407

3 months ago

1469.68ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
 
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
 
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
 
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

David Phillips

Zantier

3 months ago

1554.68ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait SleighStatus {
    fn status() -> &'static str;
}
impl SleighStatus for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl SleighStatus for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl SleighStatus for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
pub struct Sleigh<T: SleighStatus> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl<T: SleighStatus> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Default for Sleigh<Empty> {
    fn default() -> Self {
        Self::new()
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

Nelly Whads

NellyWhads

3 months ago

1257.09ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
// TODO: Define the `status` method for all states
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl<T: State> Sleigh<T> {
  pub fn status(&self) -> &'static str {
      T::status()
  }
}

Viwaswat Raj Singh

viwaswatraj

3 months ago

1307.55ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl<T:State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}

Khalifa

e1ec30

3 months ago

1487.86ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
pub struct Sleigh<T> 
where T: State
{
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl <T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

Pedro Diaz

pdiaz

4 months ago

1401.76ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
pub struct Sleigh<T>
where
    T: State,
{
    pub state: PhantomData<T>,
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

SalazarTh

4 months ago

1617.67ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
pub struct Sleigh<T>
where T: State {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

EchosinEchos

4 months ago

1675.28ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub trait Status{
    fn name()->&'static str;
}
impl Status for Empty{
    fn name()->&'static str{"Empty"}
}
impl Status for Ready{
    fn name()->&'static str{"Ready"}
}
impl Status for Flying{
    fn name()->&'static str{"Flying"}
}
// TODO: Define the `status` method for all states
pub struct Sleigh<T:Status> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl<T:Status> Sleigh<T>{
    pub fn status(&self) -> &'static str{
        T::name()
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

mednson

Mednson

4 months ago

1240.12ms

93.97kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
#[derive(Debug)]
pub struct Sleigh<T: State> {
    pub state: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl <T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}

huanderer

4 months ago

1271.09ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
#[derive(Debug)]
pub struct Sleigh<T: State> {
    pub state: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl <T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}

Aurimas Kuniutis

auriku

5 months ago

1376.26ms

93.46kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub struct Sleigh<T>
where
T: State
{
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl<T> Sleigh<T>
where
    T: State,
{
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
pub trait State {
    fn status() -> &'static str;
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}

mroslander

5 months ago

1332.35ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub struct Sleigh<T:SleighState> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
pub trait SleighState {
    fn status() -> &'static str;
}
impl SleighState for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl SleighState for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl SleighState for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
impl<T: SleighState> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}

Hung Dinh

nhdinh

5 months ago

1293.90ms

93.78kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub struct Sleigh<T: SleighState> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
pub trait SleighState {
    fn status() -> &'static str;
}
impl SleighState for Empty {
    fn status() -> &'static str { 
        "Empty" 
    }
}
impl SleighState for Flying {
    fn status() -> &'static str { 
        "Flying" 
    }
}
impl SleighState for Ready {
    fn status() -> &'static str { 
        "Ready" 
    }
}
impl<T: SleighState> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}

FredoPo

5 months ago

1280.26ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

Skippy

SkippyoftheWired

6 months ago

1313.30ms

94.87kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn  status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn  status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn  status() -> &'static str {
        "Flying"
    }
}
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl<T: State> Sleigh<T> {
    pub fn status (&self) -> &'static str {
        T::status()
    } 
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

Ahmet Özcan

ahmetoozcan

6 months ago

1403.23ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
pub struct Ready;
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
pub struct Flying;
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
// TODO: Define the `status` method for all states
pub trait State {
    fn status() -> &'static str;
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

AtlasVakyrie

6 months ago

1358.55ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl<T: State> Sleigh<T> {
  pub fn status(&self) -> &'static str {
      T::status()
  }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
pub trait State {
    fn status() -> &'static str;
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}

Leif Hadsell

Booom775

6 months ago

1366.39ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait State {
    fn status() -> &'static str;
}
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}

Harsha Aswath

raharsha

6 months ago

1261.07ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait Status {
    fn status(&self) -> String ;
}
impl Status for Sleigh<Empty> {
    fn status(&self) -> String {
        "Empty".to_string()
    }
}
impl Status for Sleigh<Ready> {
    fn status(&self) -> String {
        "Ready".to_string()
    }
}
impl Status for Sleigh<Flying> {
    fn status(&self) -> String {
        "Flying".to_string()
    }
}
pub struct Sleigh<T> 
where
    Sleigh<T>: Status
{
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

Christopher Nielson

c-nielson

6 months ago

1287.58ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub trait State {
    fn status() -> &'static str;
}
pub struct Sleigh<T: State> {
    pub state: PhantomData<T>,
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

codervijo

6 months ago

1398.62ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
pub trait State {
    fn status() -> &'static str;
}
pub struct Sleigh<T: State> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl State for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl State for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl<T: State> Sleigh<T> {
  pub fn status(&self) -> &'static str {
      T::status()
  }
}
impl State for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}