Rust - Storing state machines in HashMaps keyed by states or transitions

In Rust, creating and maintaining state machines can be an enriching yet complex task. State machines are a robust method for managing the state transitions of an application, and in this article, we will guide you on how to utilize Rust's HashMap to store state machines effectively. We will specifically focus on storing these machines keyed either by states or by transitions.

Understanding State Machines

A state machine is a computational construct used to design algorithms that operate by changing from one state to another, based on certain inputs. Each state represents a condition or situation, and transitions represent the movement between these states, triggered by various events. Key components of a state machine include:

• States: Defined statuses where the machine can exist.
• Transitions: Legal moves from one state to another, which can be keyed on input conditions.
• Events: The inputs or triggers that cause transitions between states.

Using HashMap for State Machines

Rust's HashMap is a powerful collection that allows us to associate keys with values. We can leverage this to manage state transitions efficiently in a state machine. Below, we will explore two key ways in which you might model state machines in Rust utilizing HashMaps:

HashMap Keyed by States

When using a HashMap to map states, we assign each state a HashMap where the keys are input events and the values are the resulting states. This structure allows for quick look-ups and straightforward mapping of transitions based on current states and input events.

use std::collections::HashMap;

fn main() {
    // Define state and event as simple integers for the purpose of this example
    let mut state_transitions: HashMap> = HashMap::new();

    // Define transitions for a simple traffic light state machine
    let mut green_transitions = HashMap::new();
    green_transitions.insert(0, 1); // On timer event (0), go to yellow state (1)

    let mut yellow_transitions = HashMap::new();
    yellow_transitions.insert(0, 2); // On timer event (0), go to red state (2)

    let mut red_transitions = HashMap::new();
    red_transitions.insert(0, 0); // On timer event (0), go to green state (0)

    // Populate the main transitions map
    state_transitions.insert(0, green_transitions);
    state_transitions.insert(1, yellow_transitions);
    state_transitions.insert(2, red_transitions);

    // Example usage showing a current state and event
    let current_state = 0; // Initial state: green
    let event = 0; // Timer event: 0

    // Determine the next state
    if let Some(transitions) = state_transitions.get(¤t_state) {
        if let Some(next_state) = transitions.get(&event) {
            println!("Transitioning from state {} to state {}", current_state, next_state);
        }
    }
}

HashMap Keyed by Transitions

A different approach involves using transitions as keys in the HashMap. This is useful in more complex machines where different states might follow the same patterns of transitions, making it easier to manage complex behaviors by specifying rules based on transitions rather than individual states.

struct Transition {
    from: i32,
    to: i32,
    event: i32,
}

fn main() {
    let mut transitions_map: HashMap = HashMap::new();

    // Define specific transitions
    transitions_map.insert(0, Transition { from: 0, to: 1, event: 0 }); // Green to Yellow
    transitions_map.insert(1, Transition { from: 1, to: 2, event: 0 }); // Yellow to Red
    transitions_map.insert(2, Transition { from: 2, to: 0, event: 0 }); // Red to Green

    // Current state and event
    let current_state = 0;
    let event = 0;

    // Transition lookup by event
    for transition in transitions_map.values() {
        if transition.from == current_state && transition.event == event {
            println!("Transitioning from state {} to state {}", current_state, transition.to);
        }
    }
}

Conclusion

Using Rust's HashMaps to manage state machines allows for expressive designs that map directly to the problem space. Whether you choose to map states directly or use transitions as a key, Rust provides clear benefits in terms of safety and performance. The choice between the two methods depends heavily on your application's complexity and specific requirements. With careful design, state machines can become a beautiful addition to your application’s logic.