X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=week4.mdwn;h=49a2c1f04970981309d8887c93e53ddaa8dc44f9;hp=f3d7c03062671dd1af316ecc7629cdd3f3f33b0c;hb=b059b718b62f3b4beffb3bd7fbe66af01069f9c9;hpb=b63e280ab577c442f468f8ba047be3b124d106ac

diff --git a/week4.mdwn b/week4.mdwn
index f3d7c030..49a2c1f0 100644
--- a/week4.mdwn
+++ b/week4.mdwn
@@ -506,10 +506,9 @@ result. The `larger_computation` handler also then gets passed to the next
 rightmost stage, where the head `4` is supplied to `f2`, as the `abort_handler` to
 use if that stage decides it has an early answer.
 
-Finally, notice that we don't have the result of applying `f2` to `4` etc given as
-an argument to the application of `f2` to `5` etc. Instead, we pass
+Finally, notice that we're not supplying the application of `f2` to `4` etc as an argument to the application of `f2` to `5` etc---at least, not directly. Instead, we pass
 
-	(\result_of_foldiing_over_4321. f2 5 result_of_folding_over_4321 <one_handler> <another_handler>)
+	(\result_of_folding_over_4321. f2 5 result_of_folding_over_4321 <one_handler> <another_handler>)
 
 *to* the application of `f2` to `4` as its "continue" handler. The application of `f2`
 to `4` can decide whether this handler, or the other, "abort" handler, should be
@@ -590,14 +589,29 @@ detail](http://okmij.org/ftp/Streams.html#enumerator-stream).
 >	that `5` is the outer/leftmost head of the list. That's not an efficient way
 >	to get the leftmost head.
 >	
->	We could improve this by building lists as left folds when implementing them
->	as continuation-passing style folds. We'd just replace above:
+>	We could improve this by building lists as **left folds**. What's that?
+>	
+>	Well, the right fold of `f` over a list `[a;b;c;d;e]`, using starting value z, is:
+>	
+>			f a (f b (f c (f d (f e z))))
+>	
+>	The left fold on the other hand starts combining `z` with elements from the left. `f z a` is then combined with `b`, and so on:
+>	
+>			f (f (f (f (f z a) b) c) d) e
+>	
+>	or, if we preferred the arguments to each `f` flipped:
+>	
+>			f e (f d (f c (f b (f a z))))
+>	
+>	Recall we implemented v3 lists as their own right-fold functions. We could
+>	instead implement lists as their own left-fold functions. To do that with our
+>	v5 lists, we'd replace above:
 >	
 >			let make_list = \h t. \f2 z continue_handler abort_handler.
 >				f2 h z (\z. t f2 z continue_handler abort_handler) abort_handler
 >	
->	now `extract_head` should return the leftmost head directly, using its
->	`abort_handler`:
+>	Having done that, now `extract_head` can return the leftmost head
+>	directly, using its `abort_handler`:
 >	
 >			let extract_head = \lst larger_computation. lst
 >					(\hd sofar continue_handler abort_handler. abort_handler hd)