When I talk about functional programming in Python, folks like to look for place where functional programming isn't appropriate. They latch onto finite-state automata (FSA) because "state" of an automata doesn't seem to fit with stateless objects used in functional programming.

This is a false dichotomy.

It's emphatically false in Python, where we don't have a purely functional language.

(In a purely functional language, monads can help make FSA's behave properly and avoid optimization. The use of a recursion to consume an iterable and make state transitions is sometimes hard to visualize. We don't have these constraints.)

Let's look at a trivial kind of FSA: the parity computation. We want to know how many 1-bits are in a given value. Step 1 is to expand an integer into bits.

def bits(n: int) -> Iterable[int]: if n < 0: raise ValueError(f"{n} must be >= 0") while n > 0: n, bit = divmod(n, 2) yield bit

This will transform a number into a sequence of bits. (They're in order
from LSB to MSB, which is the reverse order of the `bin()` function.)

>>> list(bits(42)) [0, 1, 0, 1, 0, 1]

Given a sequence of bits, is there an odd number or an even number? This is the parity question. The parity FSA is often depicted like this:

When the parity is in the **even** state, a 1-bit transitions to the
**odd** state. When the parity is in the **odd**, a 1-bit transitions to
the **even** state.

Clearly, this demands the **State** design pattern, right?

## An OO Implementation

Here's a detailed OO implementation using the **State** design pattern.

class Parity: def signal(self, bit: int) -> "Parity": ... class EvenParity(Parity): def signal(self, bit: int) -> Parity: if bit % 2 == 1: return OddParity() else: return self class OddParity(Parity): def signal(self, bit: int) -> Parity: if bit % 2 == 1: return EvenParity() else: return self class ParityCheck: def __init__(self): self.parity = EvenParity() def check(self, message: Iterable[int]) -> None: for bit in message: self.parity = self.parity.signal(bit) @property def even_parity(self) -> bool: return isinstance(self.parity, EvenParity)

Each of the `Parity` subclasses implements one of the states of the
FSA. The lonely `signal()` method implements state-specific behavior.
In this case, it's a transition to another state. In more complex
examples it may involve side-effects like updating a mutable data
structure to log progress.

This mapping from state to diagram to class is pretty pleasant. Folks really like to implement each state as a distinct class. It somehow feels really solid.

It's import to note the loneliness of the lonely `signal()` method.
It's all by itself in that big, empty class.

Hint. This could be a function.

It's also important to note that this kind of design is subject to odd,
unpleasant design tweaks. Ideally, the transition is *only* done by
the lonely `signal()` method. Nothing stops the unscrupulous
programmer from putting state transitions in other methods. Sigh.

We'll look at more complex kinds of state transitions later. In the UML state chart diagrams sates may also have entry actions and exit actions, a bit more complex behavior than we we're showing in this example.

## A Functional Implementation

What's the alternative? Instead of modeling state as an object with methods for behavior, we can model state as a function. The state is a function that transitions to the next state.

def even(bit: int) -> ParityF: if bit % 2 == 1: return odd else: return even def odd(bit: int) -> ParityF: if bit % 2 == 1: return even else: return odd def parity_check(message: Iterable[int], init: ParityF = None) -> ParityF: parity = init or even for bit in message: parity = parity(bit) return parity def even_parity(p: ParityF) -> bool: return p is even

Each state is modeled by a function.

The `parity_check()` function examines each bit, and applies the
current state function (either `even()` or `odd()`) to compute the
next state, and save this as the vakue of the `parity` variable.

What's the ParityF type? This:

from typing import Protocol class ParityF(Protocol): def __call__(self, bit: int) -> "ParityF": ...

This uses a Protocol to define a type with a recursive cycle in it. It
would be more fun to use something like
`ParityF = Callable[[int], "ParityF"]`, but that's not (yet)
supported.

## Some Extensions

What if we need each state to have more attributes?

Python functions have attributes. Like this: `even.some_value = 2`;
`odd.some_value = 1`. We can add all the attributes we require.

What about other functions that happen on entry to a state or exit from a state? This is trickier. My preference is to use a class as a namespace that contains a number of related functions.

class Even: @staticmethod def __call__(bit: int) -> ParityF: if bit % 2 == 1: odd.enter() return odd else: return even @staticmethod def enter() -> None: print("even") even = Even()

This seems to work out well, and keeps each state-specific material in a
single namespace. It uses static methods to follow the same design
principle as the previous example -- these are pure functions, collected
into the class only to provide a namespace so we can use `odd.enter()`
or `even.enter()`.

## TL;DR

The **State** design pattern isn't *required* to implement a FSA.