Expected struct Box got struct - rust

Question

I just started out with rust, and for practicing purposes im making a traffic light using a finite-state-machine. Unfortunately im running into some problems. For some reason rust is expecting a struct 'BOX' instead of my own structs: RED. GREEN and ORANGE. And im out of ideas on how to fix this. Please let me know if you have any ideas.
ERROR MESSAGE:
138 | Orange => {
| ^^^^^^
| |
| expected struct `Box`, found struct `Orange`
| `Orange` is interpreted as a unit struct, not a new binding
| help: introduce a new binding instead: `other_orange
//#![deny(unsafe_code)]
#![allow(clippy::empty_loop)]
#![no_main]
#![no_std]
#![feature(alloc_error_handler)]
/*Make a state machine according to the State Pattern method as described in the book. There are three states: red, green and orange. Between the
states is switched on the basis of time: 4 s, 3 s and 1 s respectively.*/
/*• The behavior of each state is described in separate classes (or in Rust
structs), independent of the state machine object.
• All state structs implement the same trait so that the state machine object (struct) can always call the same methods regardless of the current state.
• The states themselves are responsible for determining the transition to the
next condition. */
extern crate alloc;
#[allow(unused_imports)]
use alloc::boxed::Box;
use alloc_cortex_m::CortexMHeap;
use core::alloc::Layout;
// Halt on panic
use panic_halt as _; // panic handler
use cortex_m_rt::entry;
use stm32f4xx_hal as hal;
use crate::hal::{pac, prelude::*};
#[alloc_error_handler]
fn oom(_: Layout) -> ! {
loop {}
}
#[global_allocator]
static ALLOCATOR: CortexMHeap = CortexMHeap::empty();
//Make a state machine according to the State Pattern method as described in the book.
//There are three states: red, green and orange. Between the states is switched on the basis of time: 4 s, 3 s and 1 s respectively.
//• The behavior of each state is described in separate classes (or in Rust structs), independent of the state machine object.
// discribe the behavior of each state in a separate struct
struct Red;
struct Green;
struct Orange;
//• All state structs implement the same trait so that the state machine object (struct) can always call the same methods regardless of the current state.
// All state structs implement the same trait
trait TrafficLight {
fn next(self: Box<Self>) -> Box<dyn TrafficLight>;
}
//• The states themselves are responsible for determining the transition to the next condition.
impl TrafficLight for Red {
fn next(self: Box<Self>) -> Box<dyn TrafficLight> {
Box::new(Green)
}
}
impl TrafficLight for Green {
fn next(self: Box<Self>) -> Box<dyn TrafficLight> {
Box::new(Orange)
}
}
impl TrafficLight for Orange {
fn next(self: Box<Self>) -> Box<dyn TrafficLight> {
Box::new(Red)
}
}
// The state machine object (struct) can always call the same methods regardless of the current state.
struct TrafficLightMachine {
state: Box<dyn TrafficLight>,
}
impl TrafficLightMachine {
fn new() -> TrafficLightMachine {
TrafficLightMachine {
state: Box::new(Red),
}
}
fn next(&mut self) {
self.state = self.state.next();
}
}
#[entry]
fn main() -> ! {
// Initialize the allocator BEFORE you use it
{
use core::mem::MaybeUninit;
const HEAP_SIZE: usize = 1024;
static mut HEAP: [MaybeUninit<u8>; HEAP_SIZE] = [MaybeUninit::uninit(); HEAP_SIZE];
unsafe { ALLOCATOR.init(HEAP.as_ptr() as usize, HEAP_SIZE) }
}
if let (Some(dp), Some(cp)) = (
pac::Peripherals::take(),
cortex_m::peripheral::Peripherals::take(),
) {
//GPIOD ophalen
let gpiod = dp.GPIOD.split();
//pd12 is pin type
let mut led_green = gpiod.pd12.into_push_pull_output();
let mut led_red = gpiod.pd14.into_push_pull_output();
let mut led_orange = gpiod.pd13.into_push_pull_output();
//Klok instellen
let rcc = dp.RCC.constrain();
let clocks = rcc.cfgr.sysclk(48.MHz()).freeze();
// Create a delay abstraction based on SysTick
let mut delay = cp.SYST.delay(&clocks);
let mut traffic_light = TrafficLightMachine::new();
loop {
match traffic_light.state {
Red => {
led_red.set_high();
led_green.set_low();
led_orange.set_low();
delay.delay_ms(4000_u32);
traffic_light.next();
}
Green => {
led_red.set_low();
led_green.set_high();
led_orange.set_low();
delay.delay_ms(3000_u32);
traffic_light.next();
}
Orange => {
led_red.set_low();
led_green.set_low();
led_orange.set_high();
delay.delay_ms(1000_u32);
traffic_light.next();
}
}
}
}
loop {}
}