X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=week9.mdwn;h=c6dd9e83c05d965b5d7e5894f8d9932911a27d11;hp=a738524923249461788335292199116dedb75c29;hb=4bc0776e79a9bad3a6378d9f1339f62605e436fd;hpb=a07a7e1719e637449177695d4f703d656b8e5ccb

diff --git a/week9.mdwn b/week9.mdwn
index a7385249..c6dd9e83 100644
--- a/week9.mdwn
+++ b/week9.mdwn
@@ -446,9 +446,9 @@ Here's the implementation of the State monad, together with an implementation of
 	(* alternatively, an env could be implemented as type char -> int *)
 
 	type 'a reader = env -> 'a;;
-	let unit_reader (value : 'a) : 'a reader =
+	let reader_unit (value : 'a) : 'a reader =
 		fun e -> value;;
-	let bind_reader (u : 'a reader) (f : 'a -> 'b reader) : 'b reader =
+	let reader_bind (u : 'a reader) (f : 'a -> 'b reader) : 'b reader =
 		fun e -> let a = u e
 				 in let u' = f a
 				 in u' e;;
@@ -458,9 +458,9 @@ Here's the implementation of the State monad, together with an implementation of
 	(* this corresponds to having only a single mutable variable *)
 
 	type 'a state = store -> ('a, store);;
-	let unit_state (value : 'a) : 'a state =
+	let state_unit (value : 'a) : 'a state =
 		fun s -> (value, s);;
-	let bind_state (u : 'a state) (f : 'a -> 'b state) : 'b state =
+	let state_bind (u : 'a state) (f : 'a -> 'b state) : 'b state =
 		fun s -> let (a, s') = u s
 				 in let u' = f a
 				 in u' s';;
@@ -628,10 +628,10 @@ Programming languages tend to provide a bunch of mutation-related capabilities a
 	Because of the particular way the numerical identity predicates are implemented in all of these languages, it doesn't quite match our conceptual expectations. For instance, For instance, if `ycell` is a reference cell, then `ref !ycell` will always be a numerically distinct reference cell containing the same value. We get this pattern of comparisons in OCaml:
 
 		ycell == ycell
-		ycell != ref !ycell (* these aren't numerically identical *)
+		ycell != ref !ycell (* true, these aren't numerically identical *)
 
 		ycell = ycell
-		ycell = ref !ycell (* they are qualitatively indiscernible *)
+		ycell = ref !ycell (* true, they are qualitatively indiscernible *)
 
 	But now what about?
 
@@ -751,6 +751,7 @@ Programming languages tend to provide a bunch of mutation-related capabilities a
 
 	In point 7 of the Rosetta Stone discussion, the contrast between call-by-name and call-by-value evaluation order appears (though we don't yet call it that). We'll be discussing that more in coming weeks. In the [[damn]] example, continuations and other kinds of side-effects (namely, printing) make an appearance. These too will be center-stage in coming weeks.
  
+*	Now would also be a good time to read [[Advanced Topics/Calculator Improvements]]. This reviews the different systems discussed above, as well as other capabilities we can add to the calculators introduced in [week7](/reader_monad_for_variable_binding). We will be building off of that in coming weeks.
 
 
 ##Offsite Reading##