Commissioned for this museum · after Gamma, Helm, Johnson & Vlissides, 1994

State

TypeScript·1994·31 lines·1175 bytes

/**
 * State — an object whose behaviour changes with its state, without a single
 * branch anywhere asking which state it is in.
 */
type Name = "idle" | "playing" | "paused";

type State = {
	readonly name: Name;
	press?: () => State;
	stop?: () => State;
};

// A state is defined by the transitions it offers. One that omits a
// transition cannot make it: `stop` on an idle player is not an error to
// detect at runtime, it is a property that does not exist.
//
// Written as functions rather than plain values for a dull but unavoidable
// reason — idle refers to playing and playing refers back to idle, and
// values cannot be mutually recursive.
const idle = (): State => ({ name: "idle", press: playing });
const playing = (): State => ({ name: "playing", press: paused, stop: idle });
const paused = (): State => ({ name: "paused", press: playing, stop: idle });

let current = idle();

for (const action of ["press", "press", "press", "stop", "stop"] as const) {
	const transition = current[action];
	const next = transition ? transition() : null;
	console.log(`${current.name} --${action}--> ${next ? next.name : "(ignored)"}`);
	if (next) current = next;
}

Curator’s note

There is not one if in this file asking which state the object is in, and that absence is the exhibit. The alternative — a status field and a switch inside every method — is what this code is in most codebases, and it smears the machine across every function that touches it, so that adding a fourth state means finding and correctly editing all of them.

Here a state simply *is* its set of legal transitions. Look at what idle does not have: no stop. Stopping an already-idle player is not a case to detect and reject; it is a property that does not exist on the object, and the compiler knows it before the program runs. Impossible transitions become impossible to write, rather than possible to write and wrong.

The last line of output is the honest part. stop on idle is undefined, and the loop prints (ignored) rather than crashing — because "this input does nothing in this state" is a real answer a state machine has to have. Pretending otherwise is precisely how these things acquire their bugs.

What the pattern costs is that the machine is now spread across three definitions instead of gathered into one table, and there is no single place to read off every transition. For three states that is a fair trade. For thirty it is why people reach for a state chart and generate the thing instead.