EMBEDDED RUST · no_std → WASM

Enums: States You Cannot Get Wrong

Model the controller as an enum state machine and let exhaustive matching force every state to be handled, so an unhandled mode is a build error rather than undefined behaviour on the robot.

01Challenge

The controller has three named states: Align, Seek, Arrive. The match in the starter handles only two, so the build fails. Add the missing arm to make the match total, and drive the rover through the states to the pad.

Predict firstYou model a robot's mode as an enum {Idle, Moving, Fault} and forget to handle Fault in a match. What happens?

02Model

A robot is always in some mode: aligning to the goal, driving toward it, arriving. Written as booleans and if-statements, it is easy to leave a combination unhandled, and an unhandled mode is undefined behaviour on a machine that moves. Rust's enums plus exhaustive match close that gap. Name the states in an enum, match on them, and if you forget one the compiler refuses to build, naming the state you missed. The set of states you can be in is written down, and the set you handle is checked against it.

03Guided practice

1. Read the error. error[E0004]: non-exhaustive patterns: Phase::Align not covered. The compiler is naming the state you forgot. 2. Add the arm. In the match, handle Phase::Align => { let t = 1.2 * bearing; p.motors.set(-t, t); } to pivot in place toward the goal. 3. See the machine. phase_of returns Arrive when close, Align when badly off-heading, else Seek. Each has one arm. 4. Drive. Aligned, then seeking, then arriving, the rover reaches the pad and the match is total.

04Feedback

PASS WHEN Every Phase variant is handled, the match is exhaustive, and the rover drives through Align, Seek, and Arrive to the pad.

If your run fails, check:

Build fails with 'non-exhaustive patterns: Phase::Align not covered'. Add a `Phase::Align => { ... }` arm to the match.
Rover spins in place and never leaves Align. Your Align arm should pivot briefly; check that Seek drives forward with `(0.9 * dist).min(0.6)`.
You added a `_ =>` catch-all. Prefer naming `Phase::Align` explicitly so the compiler keeps checking exhaustiveness as you add states.

05Retrieve & space

Why does a `match` on an enum have to be exhaustive, and what does the compiler do if it is not?
What does `error[E0004]` name for you that a chain of if-statements would not? (the specific missing state).
Why is 'the states I can be in' being written down as a type safer than tracking modes with booleans?

06Mastery & project

Write a controller as an enum state machine whose match the compiler proves total: illegal states become build errors.

The state-machine pattern the capstone composes, and the reason embedded Rust favours enums over mode flags.

← Option: No Null, No Silent Bug Traits: Reusable Control, Zero Cost →

EMBEDDED RUST · no_std → WASM

Enums: States You Cannot Get Wrong

Model the controller as an enum with exhaustive matching. The starter will not compile until every Phase is handled.

You read

You change

the firmware you write in the control loop

Fixed

the emulated chip, its peripherals, and the wiring