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

Joseph Copenhaver

josephcopenhaver

9 hours ago

1207.65ms

94.10kb

use std::marker::PhantomData;
pub trait State {
    fn status() -> &'static str;
}
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 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 }
    }
}

Ljungg

10 hours ago

1257.12ms

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"
    }
}
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 }
    }
}

Morse

A1-exe

11 hours ago

1226.36ms

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 }
    }
}

The Scooby

thescooby

12 hours ago

1282.50ms

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 }
    }
}

James Bromley

jayber

13 hours ago

1227.83ms

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 }
    }
}

Rickard Jensen

rjensen

13 hours ago

1199.16ms

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 }
    }
}

Florian Gaudin-Delrieu

FlorianGD

13 hours ago

1287.18ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub trait Statusable {
    fn status() -> &'static str;
}
impl Statusable for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl Statusable for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl Statusable for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
// TODO: Define the `status` method for all states
impl<T: Statusable> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
pub struct Sleigh<T: Statusable> {
    // 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 }
    }
}

Florian Gaudin-Delrieu

FlorianGD

14 hours ago

1188.81ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub trait Statusable {
    fn status() -> &'static str;
}
impl Statusable for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl Statusable for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl Statusable for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
// TODO: Define the `status` method for all states
pub struct Sleigh<T: Statusable> {
    // 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 {
        Empty::status().to_string()
    }
}
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 {
        Ready::status().to_string()
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
    pub fn status(&self) -> String {
        Flying::status().to_string()
    }
}

Mingzhe Yang

mei28

15 hours ago

1217.52ms

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:Stateful> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
pub trait Stateful {
    fn status() -> &'static str;
}
impl Stateful for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl Stateful for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl Stateful for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
impl<T: Stateful> 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 }
    }
}

Mingzhe Yang

mei28

15 hours ago

1217.61ms

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:Stateful> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
pub trait Stateful {
    fn status() -> &'static str;
}
impl Stateful for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl Stateful for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl Stateful for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
impl<T: Stateful> 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 }
    }
}

sweet2honey

15 hours ago

1487.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;
}
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 }
    }
}

pagyeman

16 hours ago

1203.77ms

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 }
    }
}

PangoSea

kapaseker

21 hours ago

1203.49ms

94.87kb

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:Stateful> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
pub trait Stateful {
    fn status() -> &'static str;
}
impl Stateful for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl Stateful for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl Stateful for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
impl<T: Stateful> 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 }
    }
}

kosay

sarub0b0

a day ago

1205.91ms

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 }
    }
}

Emmanuel Guefif

eguefif

a day ago

1248.20ms

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() -> &'static str;
}
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 Status for Empty {
    fn status() ->  &'static str{
        "Empty"
    }
}
impl Status for Flying {
    fn status() ->  &'static str{
        "Flying"
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Status for Ready {
    fn status() ->  &'static str{
        "Ready"
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

Marius Gehrmann

MGehrmann

a day ago

1715.94ms

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 }
    }
}

Aaron

aaron-otis

a day ago

1169.02ms

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 }
    }
}

Kushneryk Pavel

KushnerykPavel

a day ago

1224.56ms

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 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 }
    }
}

Habu

habu1010

a day ago

1205.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;
}
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 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 }
    }
}

Vladimir Fedorov

Fedott

2 days ago

1219.44ms

101.78kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
trait Status {
    fn status() -> &'static str;
}
impl Status for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl Status for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl Status for Flying {
    fn status() -> &'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: 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 }
    }
}

hafihaf123

2 days ago

1189.24ms

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 }
    }
}

Tim Toebrock

titoeb

2 days ago

1188.19ms

94.61kb

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 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<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"
    }
}
fn main() {
    println!("{}", Sleigh::new().status());
    println!("{}", Sleigh::new().load().status());
    println!("{}", Sleigh::new().load().take_off().status());
}

Stefano Cianciulli

CianciuStyles

2 days ago

1256.89ms

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 }
    }
}

Kyaw Kyaw Khaing

Kyawkhaing444

2 days ago

1187.11ms

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 }
    }
}

gmvar

2 days ago

1368.00ms

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 }
    }
}

Grant Kinney

creativecoder

2 days ago

1289.93ms

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) -> &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 }
    }
}

Guilherme Cesário Strachan

strachan

2 days ago

1283.69ms

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 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()
    }
}

Rocky.C

cloki0610

2 days ago

1294.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 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 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()
  }
}

Wendy Kong

wendko

2 days ago

1234.00ms

94.10kb

use std::marker::PhantomData;
// 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.
pub struct Empty;
pub struct Ready;
pub struct Flying;
// trait to define shared behavior between structs
pub trait State {
    fn status() -> &'static str;
}
// impl trait for each struct (trait bounds)
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 a Sleigh for all trait bounds
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status() 
    }
}
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 }
    }
}

Ankit Kumar Jha

Ankit8848

2 days ago

1279.92ms

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 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 }
    }
}

Dominic

DominicD

2 days ago

1406.38ms

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 Marker {
    fn status() -> &'static str;
}
//impl Marker for () {}
impl Marker for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl Marker for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl Marker for Flying {
    fn status() -> &'static str {
        "Flying"
    }
}
pub struct Sleigh<T: Marker> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl<T: Marker> 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 }
    }
}

Sukrit Amornpornwiwat

arm01846

2 days ago

1253.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 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 }
    }
}

Frank

frankstolle

2 days ago

1558.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 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 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 }
    }
}

Joanne Muthoni

joanne-cmd

2 days ago

1187.81ms

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 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 }
    }
}

Rounak Sen

rony0000013

2 days ago

1219.71ms

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 }
    }
}

vaclav0411

2 days ago

1350.93ms

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 }
    }
}

Njerii

wamimi

2 days ago

1321.55ms

94.10kb

use std::marker::PhantomData;
// Define the State trait
pub trait State {
    fn status() -> &'static str;
}
pub struct Empty;
pub struct Ready;
pub struct Flying;
// Implement State trait for each state
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"
    }
}
// Update Sleigh to require State trait
pub struct Sleigh<T: State> {
    pub state: PhantomData<T>,
}
// Implement status method for all states
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 }
    }
}

Masayuki Sunahara

tamanishi

2 days ago

1397.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"
    }
}
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 }
    }
}

Michal Miškerník

miscer

2 days ago

1201.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"
    }
}
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 }
    }
}

Nikita Smirnov

Nismirno

3 days ago

1286.66ms

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 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 }
    }
}

Will LaBranche

wlabranche

3 days ago

1228.47ms

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 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 }
    }
}

joshvon44

3 days ago

1286.51ms

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()
    }
}

Burnus

3 days ago

1254.48ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub trait Status {
    fn status() -> &'static str;
}
impl Status for Empty {
    fn status() -> &'static str {
        &"Empty"
    }
}
impl Status for Ready {
    fn status() -> &'static str {
        &"Ready"
    }
}
impl Status for Flying {
    fn status() -> &'static str {
        &"Flying"
    }
}
pub struct Sleigh<T: Status> {
    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 }
    }
}

KLcpb

3 days ago

1289.16ms

93.97kb

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 }
    }
}

Claus Guttesen

kometen

3 days ago

1359.01ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub trait State {
    fn status() -> &'static str;
}
// TODO: Define the `status` method for all states
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()
    }
}

Tõnis Kevvai

tonisk

3 days ago

1211.30ms

93.97kb

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() -> String;
}
impl State for Empty {
    fn status() -> String {
        "Empty".into()
    }
}
impl State for Ready {
    fn status() -> String {
        "Ready".into()
    }
}
impl State for Flying {
    fn status() -> String {
        "Flying".into()
    }
}
impl<T: State> Sleigh<T> {
    pub fn status(&self) -> String {
        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 }
    }
}

Chris

chriswmann

3 days ago

1229.48ms

101.78kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// TODO: Define the `status` method for all states
trait Status {
    fn status() -> &'static str;
}
impl Status for Empty {
    fn status() -> &'static str {
        "Empty"
    }
}
impl Status for Ready {
    fn status() -> &'static str {
        "Ready"
    }
}
impl Status for Flying {
    fn status() -> &'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: 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 }
    }
}

GermanS

4 days ago

1284.27ms

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 }
    }
}

Luis Linares

lulingar

4 days ago

1192.79ms

94.10kb

use std::marker::PhantomData;
// 1. We have 3 states:
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" }
}
// 2. Finish the Sleigh struct definition
pub struct Sleigh<S: State> {
    _state: PhantomData<S>,
}
impl<S: State> Sleigh<S> {
    fn transition() -> Sleigh<S> {
        Sleigh {
            _state: PhantomData,
        }
    }
    pub fn status(&self) -> &'static str {
        S::status()
    }
}
// 3. Write the Sleigh Implementations for all states
impl Sleigh<Empty> {
    pub fn new() -> Sleigh<Empty> {
        Sleigh::transition()
    }
 
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh::transition()
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh::transition()
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh::transition()
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh::transition()
    }
}

Steven Luscher

steveluscher

4 days ago

1157.77ms

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: 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 }
    }
}