Day 19: State of the Sleigh

“Last year, someone called take_off mid-flight, and we ended up performing air donuts over Siberia. Never. Again.”

“It was kind of cool, though.” Prancer muttered.

Santa whirled. “Cool? COOL? I had to explain to a reindeer rescue hotline why Blitzen was tangled in GPS satellites! No more cowboy coding. We’re doing this with the type state pattern.”

Bernard hesitated. “Uh, what’s wrong with just adding a check for is_flying?”

Santa's glare could have melted the North Pole. “Oh, brilliant idea, Bernard. Let’s just trust runtime checks! No. The sleigh will know its state: parked, flying, or landed. You call take_off while flying? The compiler won’t even let you. No crashes, no ISS collisions, no lawsuits.”

Blitzen snorted. “Sounds over-engineered.”

"BLITZEN, do you want to be the first reindeer to test the emergency eject system? Get to work. I want this sleigh state-safe by tonight!"

Your Mission

We don't want to end up with a sleigh in the wrong state again and we certainly don't want the take_off method to be available when the sleigh is already flying.

And Santa doesn't want any runtime checks, so it must all be checked at compile time.

Here's what you need to do:

Finish the Sleigh struct to represent the state of the sleigh.
The Sleigh struct must have 3 states Empty, Ready and Flying.

Methods

There are a few methods we want to define for each state:

Empty State

new() an associated function that creates a new Sleigh in the Empty state.
load() a method that transitions the Sleigh from Empty to Ready.

Ready State

take_off() a method that transitions the Sleigh from Ready to Flying.
unload() a method that transitions the Sleigh from Ready to Empty.

Flying State

land() a method that transitions the Sleigh from Flying to Ready.

Hints

If you're stuck or need a starting point, here are some hints to help you along the way!

Click here to show hints.

Create three structs for each state Empty, Ready and Flying.

pub struct Empty;
pub struct Ready;
pub struct Flying;

You can create a generic struct that represents the state of the sleigh. e.g.
```
struct Sleigh<State> {
  // State must be used
}
```

Use PhantomData to ensure that the state is used in the struct without consuming any memory.

use std::marker::PhantomData;
 
struct Sleigh<State> {
    _state: PhantomData<State>,
}

Implement the methods for each state. e.g.

impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { state: PhantomData }
    }
 
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

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

1029.50ms

91.06kb

use std::marker::PhantomData;
 
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Sleigh struct definition
pub struct Sleigh<State> {
    _state: PhantomData<State>,
}
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 }
    }
}
// 3. Write the Sleigh Implementations for all states

Ljungg

10 hours ago

1020.19ms

91.06kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    _state: PhantomData<State>,
}
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

1034.07ms

90.73kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    _state: PhantomData<State>
}
// 3. Write the Sleigh Implementations for all states
impl Sleigh<Empty> {
    pub fn new() -> Sleigh<Empty> {
        Sleigh { _state: PhantomData }
    }
    pub fn load(&self) -> Sleigh<Ready> {
        Sleigh { _state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(&self) -> Sleigh<Flying> {
        Sleigh { _state: PhantomData }
    }
    pub fn unload(&self) -> Sleigh<Empty> {
        Sleigh { _state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(&self) -> Sleigh<Ready> {
        Sleigh { _state: PhantomData }
    }
}

Morse

A1-exe

11 hours ago

1067.15ms

91.06kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    _state: PhantomData<State>
}
// 3. Write the Sleigh Implementations for all states
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

13 hours ago

1110.23ms

91.06kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    _state: PhantomData<State>,
}
// 3. Write the Sleigh Implementations for all states
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Sleigh { _state: PhantomData }
    }
    pub fn load(&self) -> Sleigh<Ready> {
        Sleigh { _state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(&self) -> Sleigh<Flying> {
        Sleigh { _state: PhantomData }
    }
    pub fn unload(&self) -> Sleigh<Empty> {
        Sleigh { _state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(&self) -> Sleigh<Ready> {
        Sleigh { _state: PhantomData }
    }
}

Rickard Jensen

rjensen

13 hours ago

1012.23ms

91.06kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    _state: PhantomData<State>,
}
// 3. Write the Sleigh Implementations for all states
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

1013.57ms

91.06kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Sleigh struct definition
pub struct Sleigh<State> {
    _state: PhantomData<State>
}
// 3. Write the Sleigh Implementations for all states
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

1018.00ms

91.06kb

pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<T> {
    pub _state: std::marker::PhantomData<T>,
}
// 3. Write the Sleigh Implementations for all states
impl Sleigh<Empty> {
    pub fn new() -> Sleigh<Empty> {
        Sleigh {
            _state: std::marker::PhantomData,
        }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh {
            _state: std::marker::PhantomData,
        }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh {
            _state: std::marker::PhantomData,
        }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh {
            _state: std::marker::PhantomData,
        }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh {
            _state: std::marker::PhantomData,
        }
    }
}

sweet2honey

15 hours ago

1073.60ms

90.54kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Sleigh struct definition
pub struct Sleigh<State> {
    // State must be used
    pub _state: PhantomData<State>,
}
// 3. Write the Sleigh Implementations for all states
impl Sleigh<Empty> {
    pub fn new() -> Sleigh<Empty> {
        Self { _state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { _state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { _state: PhantomData }
    }
    
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { _state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { _state: PhantomData }
    }
}

pagyeman

17 hours ago

987.20ms

91.06kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Sleigh struct definition
pub struct Sleigh<State> {
    // State must be used
    pub _state: PhantomData<State>,
}
// 3. Write the Sleigh Implementations for all states
impl Sleigh<Empty> {
    pub fn new() -> Sleigh<Empty> {
        Self { _state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { _state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { _state: PhantomData }
    }
    
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { _state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { _state: PhantomData }
    }
}

PangoSea

kapaseker

21 hours ago

995.18ms

90.73kb


pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<T> {
    pub _state: std::marker::PhantomData<T>,
}
// 3. Write the Sleigh Implementations for all states
impl Sleigh<Empty> {
    pub fn new() -> Sleigh<Empty> {
        Sleigh {
            _state: std::marker::PhantomData,
        }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh {
            _state: std::marker::PhantomData,
        }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh {
            _state: std::marker::PhantomData,
        }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh {
            _state: std::marker::PhantomData,
        }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh {
            _state: std::marker::PhantomData,
        }
    }
}

kosay

sarub0b0

a day ago

1010.49ms

91.06kb

use std::marker::PhantomData;
// 1. We have 3 states:
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<S> {
    _state: PhantomData<S>,
}
// 3. Write the Sleigh Implementations for all states
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 }
    }
}

Marius Gehrmann

MGehrmann

a day ago

1098.05ms

90.48kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty; 
pub struct Ready; 
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    state: PhantomData<State>
}
// 3. Write the Sleigh Implementations for all states
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self {
            state: PhantomData
        }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh {
            state: PhantomData
        }
    }
}
impl Sleigh<Flying> {
    pub fn land(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
        }
    }
}

Aaron

aaron-otis

a day ago

1005.36ms

90.29kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    state: PhantomData<State>,
}
// 3. Write the Sleigh Implementations for all states
impl Sleigh<Empty> {
    pub fn new() -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { state: PhantomData }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh { state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh { state: PhantomData }
    }
}

Kushneryk Pavel

KushnerykPavel

a day ago

1021.01ms

91.06kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
pub struct Empty;
// - Ready
pub struct Ready;
// - Flying
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    _state: PhantomData<State>,
}
// 3. Write the Sleigh Implementations for all states
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { _state: PhantomData}
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh {
            _state: PhantomData::<Ready>,
        }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh { _state: PhantomData::<Flying>}
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh {
            _state: PhantomData::<Empty>,
        }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh {
            _state: PhantomData::<Ready>,
        }
    }
}

Emmanuel Guefif

eguefif

a day ago

1107.41ms

91.06kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    _state: PhantomData<State>,
}
// 3. Write the Sleigh Implementations for all states
impl Sleigh<Empty> {
    pub fn new() -> Sleigh<Empty> {
        Sleigh {
            _state: PhantomData,
        }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh {
            _state: PhantomData::<Ready>,
        }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh {
            _state: PhantomData::<Ready>,
        }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh {
            _state: PhantomData::<Flying>,
        }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh {
            _state: PhantomData::<Empty>,
        }
    }
}

Habu

habu1010

a day ago

1001.71ms

91.06kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    _state: PhantomData<State>,
}
// 3. Write the Sleigh Implementations for all states
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 }
    }
}

Stefano Cianciulli

CianciuStyles

2 days ago

1047.11ms

91.06kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
pub struct Empty;
// - Ready
pub struct Ready;
// - Flying
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    state: PhantomData<State>
}
// 3. Write the Sleigh Implementations for all states
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

1047.95ms

93.61kb

pub struct Empty;
pub struct Ready;
pub struct Flying;
pub struct Sleigh<T> {
    pub _state: std::marker::PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Sleigh<Empty> {
        Sleigh {
            _state: std::marker::PhantomData,
        }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh {
            _state: std::marker::PhantomData,
        }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh {
            _state: std::marker::PhantomData,
        }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh {
            _state: std::marker::PhantomData,
        }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh {
            _state: std::marker::PhantomData,
        }
    }
}
fn test() {
    let sleigh1 = Sleigh::new().load().take_off();
}

Kyaw Kyaw Khaing

Kyawkhaing444

2 days ago

1026.85ms

90.29kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty; 
pub struct Ready; 
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    state: PhantomData<State>
}
// 3. Write the Sleigh Implementations for all states
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self {
            state: PhantomData
        }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh {
            state: PhantomData
        }
    }
}
impl Sleigh<Flying> {
    pub fn land(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
        }
    }
}

AliShenanigans

2 days ago

1048.97ms

90.54kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    state: PhantomData<State>
}
// 3. Write the Sleigh Implementations for all states
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

1063.97ms

91.06kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    state: PhantomData<State>
}
// 3. Write the Sleigh Implementations for all states
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}
    }
}

Rocky.C

cloki0610

2 days ago

1125.85ms

91.25kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
pub struct Empty;
// - Ready
pub struct Ready;
// - Flying
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh <State> {
    _state: PhantomData<State>,
}
// 3. Write the Sleigh Implementations for all states
impl Sleigh<Empty> {
    pub fn new() -> Sleigh<Empty> {
        Sleigh{ _state: PhantomData }
    }
    pub fn load(&self) -> Sleigh<Ready> {
        Sleigh{ _state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(&self) -> Sleigh<Flying> {
        Sleigh{ _state: PhantomData }
    }
    pub fn unload(&self) -> Sleigh<Empty> {
        Sleigh{ _state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(&self) -> Sleigh<Ready> {
        Sleigh{ _state: PhantomData }
    }
}

Grant Kinney

creativecoder

2 days ago

1079.82ms

91.06kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Sleigh struct definition
pub struct Sleigh<State> {
    _state: PhantomData<State>,
}
// 3. Write the Sleigh Implementations for all states
impl Sleigh<Empty> {
    pub fn new() -> Sleigh<Empty> {
        Sleigh{ _state: PhantomData }
    }
    pub fn load(&self) -> Sleigh<Ready> {
        Sleigh{ _state: PhantomData }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(&self) -> Sleigh<Flying> {
        Sleigh{ _state: PhantomData }
    }
    pub fn unload(&self) -> Sleigh<Empty> {
        Sleigh{ _state: PhantomData }
    }
}
impl Sleigh<Flying> {
    pub fn land(&self) -> Sleigh<Ready> {
        Sleigh{ _state: PhantomData }
    }
}

Wendy Kong

wendko

2 days ago

1068.89ms

91.06kb

// We don't want to end up with a sleigh in the wrong state again and we certainly don't want the take_off method to be available when the sleigh is already flying.
// And Santa doesn't want any runtime checks, so it must all be checked at compile time.
// Here's what you need to do:
// Finish the Sleigh struct to represent the state of the sleigh.
// The Sleigh struct must have 3 states Empty, Ready and Flying.
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
use std::{marker::PhantomData};
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub struct Sleigh<State> {
    _state: PhantomData<State>,
}
// Empty State
// new() an associated function that creates a new Sleigh in the Empty state.
// load() a method that transitions the Sleigh from Empty to Ready.
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self {
            _state: PhantomData
        }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh {
            _state: PhantomData
        }
    }
}
// Ready State
// take_off() a method that transitions the Sleigh from Ready to Flying.
// unload() a method that transitions the Sleigh from Ready to Empty.
impl Sleigh<Ready> {
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh {
            _state: PhantomData
        }
    }
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh {
            _state: PhantomData
        }
    }
}
// Flying State
// land() a method that transitions the Sleigh from Flying to Ready.
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh {
            _state: PhantomData
        }
    }
}

Ankit Kumar Jha

Ankit8848

2 days ago

1053.97ms

91.06kb

// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    state: PhantomData<State>,
}
// 3. Write the Sleigh Implementations for all states
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Sleigh { 
            state: PhantomData,
        }
    }
    pub fn load(&self) -> Sleigh<Ready> {
        Sleigh {
            state: PhantomData,
        }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(&self) -> Sleigh<Flying> {
        Sleigh {
            state: PhantomData,
        }
    }
    pub fn unload(&self) -> Sleigh<Empty> {
        Sleigh {
            state: PhantomData,
        }
    }
}
impl Sleigh<Flying> {
    pub fn land(&self) -> Sleigh<Ready> {
        Sleigh {
            state: PhantomData,
        }
    }
}

Dominic

DominicD

2 days ago

1036.42ms

90.54kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<T>
{
    phantom: PhantomData<T>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Sleigh{
            phantom: PhantomData
        }
    }
    pub fn load(self) -> Sleigh<Ready>
    {
        Sleigh{
            phantom: PhantomData
        }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying>
    {
        Sleigh{
            phantom: PhantomData
        }
    }
    pub fn unload(self) -> Sleigh<Empty>
    {
        Sleigh{
            phantom: PhantomData
        }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready>
    {
        Sleigh{
            phantom: PhantomData
        }
    }
    
}
// 3. Write the Sleigh Implementations for all states

Sukrit Amornpornwiwat

arm01846

2 days ago

1078.99ms

91.06kb

// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    state: PhantomData<State>,
}
// 3. Write the Sleigh Implementations for all states
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Sleigh { 
            state: PhantomData,
        }
    }
    pub fn load(&self) -> Sleigh<Ready> {
        Sleigh {
            state: PhantomData,
        }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(&self) -> Sleigh<Flying> {
        Sleigh {
            state: PhantomData,
        }
    }
    pub fn unload(&self) -> Sleigh<Empty> {
        Sleigh {
            state: PhantomData,
        }
    }
}
impl Sleigh<Flying> {
    pub fn land(&self) -> Sleigh<Ready> {
        Sleigh {
            state: PhantomData,
        }
    }
}

Joanne Muthoni

joanne-cmd

2 days ago

1054.20ms

91.06kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    _state: PhantomData<State>,
}
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}
    }
}
// 3. Write the Sleigh Implementations for all state

Rounak Sen

rony0000013

2 days ago

1247.04ms

90.54kb

// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    _state: PhantomData<State>,
}
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}
    }
}
// 3. Write the Sleigh Implementations for all states

vaclav0411

2 days ago

1165.24ms

91.06kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    _state: PhantomData<State>,
}
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}
    }
}
// 3. Write the Sleigh Implementations for all states

Njerii

wamimi

2 days ago

1034.44ms

90.54kb

use std::marker::PhantomData;
// Define the state types
pub struct Empty;
pub struct Ready;
pub struct Flying;
// Define the Sleigh with generic state
pub struct Sleigh<State> {
    _state: PhantomData<State>,
}
// Implementation for Empty state
impl Sleigh<Empty> {
    // Associated function to create new sleigh in Empty state
    pub fn new() -> Self {
        Self {
            _state: PhantomData,
        }
    }
    // Method to transition from Empty to Ready
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh {
            _state: PhantomData,
        }
    }
}
// Implementation for Ready state
impl Sleigh<Ready> {
    // Method to transition from Ready to Flying
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh {
            _state: PhantomData,
        }
    }
    // Method to transition from Ready to Empty
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh {
            _state: PhantomData,
        }
    }
}
// Implementation for Flying state
impl Sleigh<Flying> {
    // Method to transition from Flying to Ready
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh {
            _state: PhantomData,
        }
    }
}

Masayuki Sunahara

tamanishi

2 days ago

1058.87ms

90.54kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    _state: PhantomData<State>,
}
// 3. Write the Sleigh Implementations for all states
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 Sleigh {
//     pub fn new() -> Self {
//         Self {
//              state: State::Empty,
//         }
//     }
//     pub fn load(&mut self) {
//         self.state = State::Ready;
//     }
//     pub fn take_off(&mut self) {
//         self.state = State::Flying;
//     }
//     pub fn unload(&mut self) {
//         self.state = State::Empty;
//     }
//     pub fn land(&mut self) {
//         self.state = State::Ready;
//     }
// }

Michal Miškerník

miscer

2 days ago

1065.62ms

90.54kb

use std::marker::PhantomData;
// 1. We have 3 states:
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    _state: PhantomData<State>
}
// 3. Write the Sleigh Implementations for all states
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

1182.72ms

90.22kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<T> {
    state: PhantomData<T>,
}
// 3. Write the Sleigh Implementations for all states
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Sleigh {
            state: PhantomData,
        }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh {
            state: PhantomData,
        }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh {
            state: PhantomData,
        }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh {
            state: PhantomData,
        }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh {
            state: PhantomData,
        }
    }
}

gmvar

3 days ago

1181.79ms

91.06kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    _state: PhantomData<State>,
}
// 3. Write the Sleigh Implementations for all states
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

3 days ago

1083.75ms

90.73kb

// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub trait SleighState {}
pub struct Empty;
impl SleighState for Empty {}
pub struct Ready;
impl SleighState for Ready {}
pub struct Flying;
impl SleighState for Flying {}
use std::marker::PhantomData;
// 2. Finish the Sleigh struct definition
pub struct Sleigh<S: SleighState> {
    state: PhantomData<S>
}
// 3. Write the Sleigh Implementations for all states
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

1059.20ms

91.06kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    _state: PhantomData<State>,
}
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,
        }
    }
}

Burnus

3 days ago

990.81ms

91.06kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub struct Sleigh<State> {
    _phantom_data: PhantomData<State>
}
impl Sleigh<Empty> {
    pub fn new() -> Sleigh<Empty> {
        Sleigh {
            _phantom_data: PhantomData::<Empty>
        }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh {
            _phantom_data: PhantomData::<Ready>
        }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh {
            _phantom_data: PhantomData::<Flying>
        }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh {
            _phantom_data: PhantomData::<Empty>
        }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh {
            _phantom_data: PhantomData::<Ready>
        }
    }
}

KLcpb

3 days ago

1961.81ms

90.54kb

// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<T> {
    _state: PhantomData<T>,
}
// 3. Write the Sleigh Implementations for all states
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 }
    }
}

Tõnis Kevvai

tonisk

3 days ago

1034.45ms

91.06kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
// 2. Finish the Seligh struct definition
pub enum State {
    Empty,
    Ready,
    Flying,
}
pub struct Empty;
pub struct Ready;
pub struct Flying;
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 }
    }
}
// 3. Write the Sleigh Implementations for all states

James Bromley

jayber

3 days ago

1065.39ms

90.16kb

// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<T> {
    _state: PhantomData<T>,
}
// 3. Write the Sleigh Implementations for all states
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

1098.76ms

90.54kb

// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State = Empty> {
    _state: PhantomData<State>
}
// 3. Write the Sleigh Implementations for all states
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self { _state: PhantomData }
    }
    pub fn load( self ) -> Sleigh<Ready> {
        Sleigh {
            _state: PhantomData::<Ready>
        }
    }
}
impl Sleigh<Ready> {
    pub fn take_off( self ) -> Sleigh<Flying> {
        Sleigh {
            _state: PhantomData::<Flying>
        }
    }
    pub fn unload( self ) -> Sleigh<Empty> {
        Sleigh {
            _state: PhantomData::<Empty>
        }
    }
}
impl Sleigh<Flying> {
    pub fn land( self ) -> Sleigh<Ready> {
        Sleigh {
            _state: PhantomData::<Ready>
        }
    }
}

Claus Guttesen

kometen

4 days ago

1032.03ms

90.54kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Sleigh struct definition
pub struct Sleigh<State> {
    state: PhantomData<State>,
}
// 3. Write the Sleigh Implementations for all states
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Self {
            state: PhantomData
        }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh {
            state: PhantomData
        }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        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<Empty> {
        Sleigh {
            state: PhantomData
        }
    }
}

zkar0927

4 days ago

1105.07ms

91.06kb

// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    _state: State,
}
// 3. Write the Sleigh Implementations for all states
//
impl Sleigh<Empty> {
    pub fn new() -> Sleigh<Empty> {
        Sleigh::<Empty> { _state: Empty {} }
    }
    pub fn load(self) -> Sleigh<Ready> {
        Sleigh::<Ready> { _state: Ready {} }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(self) -> Sleigh<Flying> {
        Sleigh::<Flying> { _state: Flying {} }
    }
    pub fn unload(self) -> Sleigh<Empty> {
        Sleigh::<Empty> { _state: Empty {} }
    }
}
impl Sleigh<Flying> {
    pub fn land(self) -> Sleigh<Ready> {
        Sleigh::<Ready> { _state: Ready {} }
    }
}

Luis Linares

lulingar

4 days ago

998.73ms

91.06kb

use std::marker::PhantomData;
// 1. We have 3 states:
pub struct Empty; 
pub struct Ready; 
pub struct Flying; 
pub trait State {}
impl State for Empty {}
impl State for Ready {}
impl State for 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,
        }
    }
}
// 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()
    }
}

wishkus

4 days ago

1022.97ms

90.73kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    _state: PhantomData<State>
}
// 3. Write the Sleigh Implementations for all states
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}
    }
}

Stephan Lindner

Stephan-Lindner

4 days ago

990.93ms

91.06kb

use std::marker::PhantomData;
pub struct Empty;
pub struct Ready;
pub struct Flying;
pub struct Sleigh<State> {
    _marker: PhantomData<State>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Sleigh {
            _marker: PhantomData,
        }
    }
    pub fn load(&self) -> Sleigh<Ready> {
        Sleigh{
            _marker: PhantomData,
        }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(&self) -> Sleigh<Flying> {
        Sleigh{
            _marker: PhantomData,
        }
    }
    pub fn unload(&self) -> Sleigh<Empty> {
        Sleigh{
            _marker: PhantomData,
        }
    }
}
impl Sleigh<Flying> {
    pub fn land(&self) -> Sleigh<Ready> {
        Sleigh{
            _marker: PhantomData,
        }
    }
}

Stephan Lindner

Stephan-Lindner

4 days ago

989.13ms

91.57kb

use std::marker::PhantomData;
pub struct Empty {}
pub struct Ready {}
pub struct Flying {}
trait State {}
pub struct Sleigh<State> {
    _marker: PhantomData<State>,
}
impl Sleigh<Empty> {
    pub fn new() -> Self {
        Sleigh {
            _marker: PhantomData,
        }
    }
    pub fn load(&self) -> Sleigh<Ready> {
        Sleigh{
            _marker: PhantomData,
        }
    }
}
impl Sleigh<Ready> {
    pub fn take_off(&self) -> Sleigh<Flying> {
        Sleigh{
            _marker: PhantomData,
        }
    }
    pub fn unload(&self) -> Sleigh<Empty> {
        Sleigh{
            _marker: PhantomData,
        }
    }
}
impl Sleigh<Flying> {
    pub fn land(&self) -> Sleigh<Ready> {
        Sleigh{
            _marker: PhantomData,
        }
    }
}

Chris

chriswmann

4 days ago

1112.77ms

90.54kb

use std::marker::PhantomData;
// 1. We have 3 states:
// - Empty
// - Ready
// - Flying
pub struct Empty;
pub struct Ready;
pub struct Flying;
// 2. Finish the Seligh struct definition
pub struct Sleigh<State> {
    _state: PhantomData<State>,
}
// 3. Write the Sleigh Implementations for all states
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 }
    }
}