X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=topics%2Fweek1.mdwn;h=7f717d9a0cf40f1367340a6b62b64d676ecb83c2;hp=0bbea4ea8d3741111c98d8f1642713fbe9361281;hb=c10e4dd6e3e70551ba4e619dff1363c54af53afa;hpb=2ad0964b1abb9ac6b49ca5dab5ae1b95a967d75a

diff --git a/topics/week1.mdwn b/topics/week1.mdwn
index 0bbea4ea..7f717d9a 100644
--- a/topics/week1.mdwn
+++ b/topics/week1.mdwn
@@ -383,8 +383,8 @@ is a pattern, meaning the same as `x1 & x2 & []`. Note that while `x & xs` match
 For the time being, these are the only patterns we'll allow. But since the definition of patterns is recursive, this permits very complex patterns. What would this evaluate to:
 
     let
-      ([x, y], [z:zs, w]) match ([[], [1]], [[10, 20, 30], [0]])
-    in (z, y)
+      ([xs, ys], [z:zs, ws]) match ([[], [1]], [[10, 20, 30], [0]])
+    in z & ys
 
 Also, we will permit complex patterns in λ-expressions, too. So you can write:
 
@@ -473,7 +473,7 @@ or, using `case`:
   `factorial match` λ `n. case n of 0 then 1; _ then n * factorial (n - 1) end`  
 `in factorial`
 
-But there's a problem here. What value does `factorial` have when evaluating the expression `factorial (n - 1)`?
+But there's a problem here. What value does `factorial` have when evaluating the subexpression `factorial (n - 1)`?
 
 As we said in class, the natural precedent for this with non-function variables would go something like this:
 
@@ -540,7 +540,7 @@ Finally, we're in a position to revisit the two definitions of `length` that Jim
   `length match` λ `xs. case xs of [] then 0; _:ys then 1 + length ys end`  
 `in length`
 
-This function accept a sequence `xs`, and if its empty returns `0`, else it says that its length is `1` plus whatever is the length of its remainder when you take away the first element. In programming circles, this remainder is commonly called the sequence's "tail" (and the first element is its "head").
+This function accept a sequence `xs`, and if it's empty returns `0`, else it says that its length is `1` plus whatever is the length of its remainder when you take away the first element. In programming circles, this remainder is commonly called the sequence's "tail" (and the first element is its "head").
 
 Thus if we evaluated `length [10, 20, 30]`, that would give the same result as `1 + length [20, 30]`, which would give the same result as `1 + (1 + length [30])`, which would give the same result as `1 + (1 + (1 + length []))`. But `length []` is `0`, so our original expression evaluates to `1 + (1 + (1 + 0))`, or `3`.
 
@@ -614,3 +614,28 @@ You have all the materials you need now to do this week's [[assignment|assignmen
 
 There are also some [[advanced notes|week1 advanced notes]] extending this week's material.
 
+### Summary ###
+
+Here is the hierarcy of **values** that we've talked about so far.
+
+*   Multivalues
+*   Singular values, including:
+    *   Atoms, including:
+        *   Numbers: these are among the **literals**
+        *   Symbolic atoms: these are also among the **literals**, and include:
+            *   Booleans (or truth-values)
+        *   Functions: these are not literals, but instead have to be generated by evaluating complex expressions
+    *   Containers, including:
+        *   the **literal containers** `[]` and `{}`
+        *   Non-empty sequences
+        *   Non-empty sets
+        *   Tuples proper and other containers, to be introduced later
+
+We've also talked about a variety of **expressions** in our language, that evaluate down to various values (if their evaluation doesn't "crash" or otherwise go awry). These include:
+
+*   All of the literal atoms and literal containers
+*   Variables
+*   Various complex expressions, built using `&` or λ or `let` or `letrec` or `case`
+
+The special syntaxes `[10, 20, 30]` are just shorthand for the more offical syntax using `&` and `[]`, and likewise for `{10, 20, 30}`. The `if ... then ... else ...` syntax is just shorthand for a `case`-construction using the literal patterns `'true` and `'false`.
+