X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=topics%2Fweek2_lambda_intro.mdwn;h=e8aa8467c3f9339ee37210651d7e9121d6cecc5a;hp=d002abf8da0287a592c2286749f95f22a2326ab6;hb=d99aa0c25495644522b9214dcb7b6e18e553586b;hpb=ddafcdc11f354d8ce4be628b006316c57083d1ec

diff --git a/topics/week2_lambda_intro.mdwn b/topics/week2_lambda_intro.mdwn
index d002abf8..e8aa8467 100644
--- a/topics/week2_lambda_intro.mdwn
+++ b/topics/week2_lambda_intro.mdwn
@@ -252,7 +252,7 @@ function?  One popular answer is that a function can be represented by
 a set of ordered pairs.  This set is called the **graph** of the
 function.  If the ordered pair `(a, b)` is a member of the graph of `f`,
 that means that `f` maps the argument `a` to the value `b`.  In
-symbols, `f: a` ↦ `b`, or `f (a) == b`.  
+symbols, `f: a` ↦ `b`, or `f (a) == b`.
 
 In order to count as a *function* (rather
 than as merely a more general *relation*), we require that the graph not contain two
@@ -288,7 +288,7 @@ lambda calculus, note that duplicating, reordering, and deleting
 elements is all that it takes to simulate the behavior of a general
 word processing program.  That means that if we had a big enough
 lambda term, it could take a representation of *Emma* as input and
-produce *Hamlet* as a result. 
+produce *Hamlet* as a result.
 
 Some of these functions are so useful that we'll give them special
 names.  In particular, we'll call the identity function `(\x x)`
@@ -317,7 +317,7 @@ are distinct lambda expressions:
 
     (\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
@@ -432,12 +432,12 @@ reasons sketched above.
 ## The analogy with `let` ##
 
 In our basic functional programming language, we used `let`
-expressions to assign values to variables.  For instance, 
+expressions to assign values to variables.  For instance,
 
     let x match 2
-    in (x, x) 
+    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.
 
@@ -445,7 +445,7 @@ construction.
 
 is analogous to
 
-    let x match ARG 
+    let x match ARG
     in BODY
 
 This analogy should be treated with caution.  For one thing, our `letrec`