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

Christopher Nielson

c-nielson

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

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

ckab

ckab04

15 days ago

1263.14ms

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

Leandro Abreu

leandronowras

17 days ago

1272.89ms

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

gsspdev

23 days ago

1312.04ms

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

Ido Barkan

barkanido

24 days ago

1490.18ms

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

Duncan Macharia

Devdannetworks

25 days ago

1427.15ms

94.10kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
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"
    }
}
pub struct Sleigh<T: SleighState> {
    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 }
    }
}
// Add a `status` method for all `Sleigh` instances
impl<T: SleighState> Sleigh<T> {
    pub fn status(&self) -> &'static str {
        T::status()
    }
}

Artem

CaptainBloodborne

25 days ago

1271.16ms

94.87kb

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

Artem

CaptainBloodborne

25 days ago

1185.96ms

94.10kb

use std::marker::PhantomData;
pub trait SelighStatus {
    fn status() -> String;
}
pub struct Empty;
pub struct Ready;
pub struct Flying;
impl SelighStatus for Empty {
    fn status() -> String {
        "Empty".to_string()
    }
}
impl SelighStatus for Ready {
    fn status() -> String {
        "Ready".to_string()
    }
}
impl SelighStatus for Flying {
    fn status() -> String {
        "Flying".to_string()
    }
}
// TODO: Define the `status` method for all states
pub struct Sleigh<T: SelighStatus> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    pub state: PhantomData<T>,
}
impl <T: SelighStatus> 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 }
    }
}

rockman

a month ago

1280.28ms

93.97kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
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"
    }
}
// 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 Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
    pub fn status(&self) -> &'static str {
        Empty.status()
    }
}
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) -> &'static str {
        Ready.status()
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
    pub fn status(&self) -> &'static str {
        Flying.status()
    }
}
//

Job Matheka

jobm

a month ago

1279.02ms

102.23kb

use std::marker::PhantomData;
// Define the state structs
pub struct Empty;
pub struct Ready;
pub struct Flying;
// Define the `State` trait with a `status` method
trait State {
    fn status() -> &'static str;
}
// 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"
    }
}
// Define the `Sleigh` struct with a generic state
pub struct Sleigh<T: State> {
    state: PhantomData<T>,
}
// Implement methods for `Sleigh` in any state
impl<T: State> Sleigh<T> {
    /// Returns the current status of the sleigh
    pub fn status(&self) -> &'static str {
        T::status()
    }
}
// Implement methods specific to the `Empty` state
impl Sleigh<Empty> {
    /// Creates a new sleigh in the `Empty` state
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
    /// Transitions the sleigh to the `Ready` state
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
// Implement methods specific to the `Ready` state
impl Sleigh<Ready> {
    /// Transitions the sleigh to the `Flying` state
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    /// Transitions the sleigh back to the `Empty` state
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
// Implement methods specific to the `Flying` state
impl Sleigh<Flying> {
    /// Transitions the sleigh back to the `Ready` state
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

Psychloor

a month ago

1232.66ms

94.29kb

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

Kj

kj-9

a month ago

1271.05ms

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

Antoine Plard

tylp

a month ago

1232.83ms

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

arilet

a month ago

1259.56ms

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

isaaclv

a month ago

1317.35ms

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

Derek Chen-Becker

dchenbecker

a month ago

1314.18ms

94.29kb

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

Francisco López

franlopezm

a month ago

1236.05ms

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

Finn

soxfox42

a month ago

1247.92ms

94.10kb

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

Sergei Chertkov

mamont

a month ago

1290.22ms

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 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"
    }
}
impl<T: State> Sleigh<T> {
  pub fn status(&self) -> &'static str {
      T::status()
  }
}

Ferdinand de Baecque

Ferdinanddb

a month ago

1209.83ms

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

Kinuko Yasuda

kinu

a month ago

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

GoT

PierreRambaud

a month ago

1230.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;
}
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> {
    // This is only public for testing purposes
    // In real-world scenarios, this should be private
    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 }
    }
}

Tengz Mao

MaoX-Yu

a month ago

1190.44ms

93.78kb

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

stanisgo

a month ago

1233.48ms

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

Joseph Copenhaver

josephcopenhaver

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

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

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

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

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

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

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

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

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

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

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

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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

2 months 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

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