((\x (\y (x y))) x)
-We didn't have to insert any parentheses around the inner body of `\y. (x y)` because they were already there.
+The outermost parentheses were added because we have an application. `(\x. \y.
+...)` became `(\x (\y. ...))` because of the rule for dots. We didn't have to
+insert any parentheses around the inner body of `\y. (x y)` because they were
+already there. That is, in expressions of the form `\y. (...)`, the dot abbreviates
+nothing. It's harmless to write such a dot, though, and it can be conceptually
+helpful especially in light of the next convention...
**Merging lambdas** An expression of the form `(\x (\y M))`, or equivalently, `(\x. \y. M)`, can be abbreviated as:
simply returns `M`: `((\x x) M) ~~> M`.
> `(\x (x x))` duplicates its argument (applies it to itself):
-`((\x (x x)) M) ~~> (M M)` <!-- **M** or ω; W is \uv.uvv -->
+`((\x (x x)) M) ~~> (M M)` <!-- **M** or ω; W is \uv.uvv, L is \uv.u(vv) -->
> `(\x (\y (y x)))` reorders its two arguments:
`(((\x (\y (y x))) M) N) ~~> (N M)` <!-- **T**; C is \uvx.uxv -->
(\z z)
-yet when applied to any argument M, all of these will always return M. So they
+yet when applied to any argument `M`, all of these will always return `M`. So they
have the same extension. It's also true, though you may not yet be in a
position to see, that no other function can differentiate between them when
they're supplied as an argument to it. However, these expressions are all
let x match 2
in (x, x)
-evaluates to the ordered pair (2, 2). It may be helpful to think of
+evaluates to the ordered pair `(2, 2)`. It may be helpful to think of
a redex in the lambda calculus as a particular sort of `let`
construction.