Dynamic Finite-State-Machine in Rust

fsm.rs

use std::fmt::Debug;

pub trait State: Debug {
    fn execute(&self) -> Transition;
}

pub trait TransitionTo<S: State + 'static>: State {
    fn transition_to(&self, to: &'static S) -> Transition {
        Transition { to }
    }
}

pub struct Transition {
    to: &'static dyn State,
}

impl Transition {
    pub fn to(&self) -> &'static dyn State {
        self.to
    }
}

main.rs

mod fsm;

use std::time::Duration;

use crate::fsm::{State, TransitionTo, Transition};

#[derive(Debug)]
struct StateA;
#[derive(Debug)]
struct StateB;

impl State for StateA {
    fn execute(&self) -> Transition {
        self.transition_to(&StateB)
    }
}

impl TransitionTo<StateB> for StateA {}

impl State for StateB {
    fn execute(&self) -> Transition {
        self.transition_to(&StateA)
    }
}

impl TransitionTo<StateA> for StateB {}

fn main() {
    let mut state: &dyn State = &StateA;
    loop {
        println!("{:?}", state);
        std::thread::sleep(Duration::from_secs(1));
        let transition = state.execute();
        state = transition.to();
    }
}