Design Patterns for Swift: Mastering State Machines

By /

Design Patterns for Swift: Mastering State Machines

State machines have become an essential part of software development, especially in the world of mobile application development. With the advent of the Swift programming language, developers now have a powerful and expressive tool to create robust and efficient state machines. In this article, we’ll explore the fundamentals of state machines and how to use them in Swift code.

State machines can be used to model complex behaviors. They are used in a wide variety of applications, including robotics, gaming, embedded systems, and user interfaces. At its core, a state machine is a finite set of states that define how the system behaves under certain conditions. Each state has a set of rules that define what happens when the system moves from one state to another.

To illustrate how a state machine works, let’s consider a simple example. Suppose we have a game with a character that can move left, right, up, and down. The game could be represented as a state machine, with four states: left, right, up, and down. Each state has a set of rules that define what happens when the character moves from one state to another. For example, when the character moves from left to right, the game might move the character to the right side of the screen.

Swift makes it easy to implement state machines. To get started, let’s create a struct called `State` to represent a single state in the state machine: 

struct State {
    let name: String
    let rules: [Rule]
}

The `name` property stores the name of the state, while the `rules` property stores an array of `Rule` objects that define the behavior of the state. Now let’s create a `Rule` struct that defines the behavior of a single state transition: 

struct Rule {
    let from: State
    let to: State
    let action: () -> Void
}

Each `Rule` object contains a `from` and `to` property that define which states the rule applies to, and an `action` closure that is executed when the rule is triggered.

Now that we have our basic structures defined, let’s create a `StateMachine` class to manage the state transitions: 

class StateMachine {
    var currentState: State
    var rules: [Rule]

    init(initialState: State) {
        self.currentState = initialState
        self.rules = []
    }

    func addRule(_ rule: Rule) {
        self.rules.append(rule)
    }

    func transition(to state: State) {
        guard let rule = rules.first(where: { $0.from == currentState && $0.to == state }) else {
            return
        }
        currentState = state
        rule.action()
    }
}

The `StateMachine` class stores a `currentState` property to track the current state of the machine, and a `rules` array to store all of the applicable rules. The `addRule(_:)` method is used to add a new rule to the machine, and the `transition(to:)` method is used to trigger a state transition.

To demonstrate how to use the `StateMachine` class, let’s create a simple example that models a traffic light. We’ll start by creating three states for the traffic light: `green`, `yellow`, and `red`: 

let green = State(name: "Green", rules: [])
let yellow = State(name: "Yellow", rules: [])
let red = State(name: "Red", rules: [])

Next, let’s create a `StateMachine` instance and add the states to it: 

let stateMachine = StateMachine(initialState: green)
stateMachine.addRule(Rule(from: green, to: yellow, action: { print("Turning yellow") }))
stateMachine.addRule(Rule(from: yellow, to: red, action: { print("Turning red") }))
stateMachine.addRule(Rule(from: red, to: green, action: { print("Turning green") }))

Finally, let’s trigger a state transition by calling the `transition(to:)` method: 

stateMachine.transition(to: yellow) // prints "Turning yellow"

In this article, we’ve explored the fundamentals of state machines and how to use them in Swift code. We created a `State` struct to represent a single state in the state machine, a `Rule` struct to define the behavior of a single state transition, and a `StateMachine` class to manage the state transitions. Using these tools, we were able to create a simple example that models a traffic light.

State machines are a powerful and expressive tool for modeling complex behaviors. By using the Swift programming language, developers now have a powerful and expressive tool to create robust and efficient state machines.

Scroll to Top