X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=topics%2Fweek3_lists.mdwn;h=08b35162f470f8e61293534faa7c2633bbb1848b;hp=8d646f1713213b644ab01f744f41fc07a0e0df2d;hb=78cfc3595320d328af3892701b8ba7973a1538e3;hpb=b93e99adfad61e703393d71f919af78a10b02101

diff --git a/topics/week3_lists.mdwn b/topics/week3_lists.mdwn
index 8d646f17..08b35162 100644
--- a/topics/week3_lists.mdwn
+++ b/topics/week3_lists.mdwn
@@ -1,5 +1,6 @@
 # More on Lists #
 
+<a id=comprehensions></a>
 ## Comprehensions ##
 
 We know you are already familiar with the following kind of notation for designating sets:
@@ -48,7 +49,7 @@ Haskell also has an extension that permits you to iterate over multiple lists *i
 
     [ 10*x + y | y <- [4, 5, 6] | x <- [1, 2, 3] ]
 
-will evaluate to `[14, 25, 36]`. If the lists are of unequal length, Haskell stops when it exhausts the first. These behaviors are similar to the `map2` function you defined in the week 1 homework. That also took an argument from each of several sequences in parallel. (The corresponding functions in Haskell are called `zip` and `zipWith`.)
+will evaluate to `[14, 25, 36]`. If the lists are of unequal length, Haskell stops when it exhausts the shortest. These behaviors are similar to the `map2` function you defined in the week 1 homework. That also took an argument from each of several sequences in parallel. (The corresponding functions in Haskell are called `zip` and `zipWith`.)
 
 OCaml [permits lists comprehensions as an extension](http://stackoverflow.com/questions/27652428/list-comprehension-in-ocaml), and [so too does Scheme](http://srfi.schemers.org/srfi-42/srfi-42.html), but these are a bit harder to use.
 
@@ -88,7 +89,7 @@ This gives us nearly what we want. It evaluates to:
 
     [[14, 24, 34], [15, 25, 35]]
 
-Why? Because the `filter` expression at the end is restricting the domain that `y` ranges over to `[4, 5]`. Over this domain we are selecting a value to bind `y` to, and then evaluating the inner `map` expression with `y` so bound. With `y` bound to `4`, we get the result `[14, 24, 34]`. With `y` bound to `5`, we get the result `[15, 25, 35]`. These two results, in order, are the elements that make up the sequence which is the result of the outermost `map` expression.
+Why? Because the `filter` expression at the end is restricting the domain that `y` ranges over to `[4, 5]`. Over this domain we are selecting a value to bind `y` to, and then evaluating the `map` expression inside `f` with `y` so bound. With `y` bound to `4`, we get the result `[14, 24, 34]`. With `y` bound to `5`, we get the result `[15, 25, 35]`. These two results, in order, are the elements that make up the sequence which is the result of the outermost `map` expression.
 
 One final twist is that our original list comprehension gives us a "flatter" result. In both Kapulet (and Haskell, modulo a few syntax adjustments), the list comprehension:
 
@@ -119,6 +120,8 @@ not to:
 To get the latter, you'd need to apply `join` twice.
 
 
+
+<a id=tails></a>
 ## Tails ##
 
 For the Lambda Calculus, we've proposed to encode lists in terms of higher-order functions that perform right-folds on (what we intuitively regard as) the real list. Thus, the list we'd write in Kapulet or Haskell as:
@@ -151,3 +154,5 @@ Try it out in the lambda evaluator. After the code above, you can write:
 
 and the result will be `\f z. f b (f c z)`, our encoding of `[b, c]`.
 
+
+<a id=v2-lists></a>