How do you evaluate a nested payroll expression by the substitution model, one step at a time?

## Rewriting, not running The substitution model is a way of saying what an expression **means** without talking about machines. There is no memory to look at and no instruction pointer to follow. There is only a sequence of expressions, each obtained from the previous one by a rewrite, each denoting the same value as the previous one, ending in a value that no longer contains a call. Working through a payroll expression this way is the single most useful thing purity buys a reader, and interviewers ask for the trace because it is impossible to fake. The one rewrite that does all the work is: **replace a call by the function's body, with the argument values written in for the parameters.** Everything else is ordinary arithmetic on the result. ## The procedure 1. **Find a call** in the current expression. 2. **Write out its body**, substituting the values of the arguments for every occurrence of the corresponding parameter. 3. **Reduce** any arithmetic or built-in operation now fully applied to values. 4. **Repeat** from step 1 until the expression contains no calls. The trace below takes six rewrites to get from `net(5000)` to `3850`, with `tax(g) = g * 0.18` and `pension(g) = g * 0.05`: ``` net(5000) = 5000 - tax(5000) - pension(5000) // body of net, 5000 for g = 5000 - (5000 * 0.18) - pension(5000) // body of tax = 5000 - 900 - pension(5000) = 5000 - 900 - (5000 * 0.05) // body of pension = 5000 - 900 - 250 = 3850 ``` Here the choice at each step was to take the innermost remaining call. A trace is a proof written down: any reader can check each line against the one above it without knowing anything about the rest of the program. ## What each column of the trace tells you | the rewrite | what it replaces | what it needs to be legal | |---|---|---| | unfolding a call | the call | the function's body, with arguments substituted for parameters | | reducing an operation | an operation applied to values | the operation's own definition | | folding a call back | a value | a definition that produces exactly that value | The third row is the same rewrite as the first, read right to left, and it is what you use when you go looking for the shorter expression that means the same thing. ## What breaks the model - **A name that can be rebound.** If `gross` denotes `5000` on line two and `4800` three lines later, the trace is no longer a chain of equal expressions; every line after the rebinding is about a different program. This is the deep reason a mutation-heavy style cannot be read this way: you must simulate the machine instead, tracking what each name currently holds. - **A call whose second evaluation disagrees with its first.** Substituting it means writing down one value where the program would have produced two, and the trace quietly stops describing the program. - **A call that does something on the way.** Replacing it by a value erases that happening from the trace, so the trace is no longer a faithful account of what the run does. - **Arithmetic that is not what you assumed.** Step 3 reduces an operation using its actual definition. If the numbers are represented with limited precision, the reduction is the one the representation performs, not the textbook one. ## Why it is worth practising Because debugging becomes reading. When a payslip comes out wrong, a substitution trace localises the defect to the first line you disagree with: everything above it is arithmetic you accept, everything below follows from it. You never have to ask "what was the state at that moment", because there is no state — only expressions. The same skill is what makes review fast: a reviewer who can unfold two calls in their head can tell whether the rewrite in the diff preserved meaning without checking out the branch. The trap to avoid at this level is confusing the model with an implementation. Real machines do not re-copy function bodies around; they push frames and jump. The substitution model claims nothing about how the work is carried out. It claims that the *answer* is the one the rewrite chain arrives at — which is precisely the claim a pure function lets you make.