X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=hints%2Fassignment_7_hint_5.mdwn;h=d44f824b05968d6de85e0cbc5b46ef97c77205b5;hp=2e7808a1ae62a8642095c71e397a0112e8820d60;hb=399197e0af7c4b80f326be60ff2c0caae74b3687;hpb=c6f572fd09dbe53dff30a91cd07b318b3e5edfd6

diff --git a/hints/assignment_7_hint_5.mdwn b/hints/assignment_7_hint_5.mdwn
index 2e7808a1..d44f824b 100644
--- a/hints/assignment_7_hint_5.mdwn
+++ b/hints/assignment_7_hint_5.mdwn
@@ -1,3 +1,14 @@
+<!--
+I would like to propose one pedegogical suggestion (due to Ken), which
+is to separate peg addition from non-determinacy by explicitly adding
+a "Let" construction to GSV's logic, i.e., "Let of var * term *
+clause", whose interpretation adds a peg, assigns var to it, sets the
+value to the value computed by term, and evaluates the clause with the
+new peg in place.  This can be added easily, especially since you have
+supplied a procedure that handles the main essence of the
+construction.  Once the Let is in place, adding the existential is
+purely dealing with nondeterminism.
+-->
 
 *	How shall we handle \[[&exist;x]]? As we said, GS&V really tell us how to interpret \[[&exist;xPx]], but for our purposes, what they say about this can be broken naturally into two pieces, such that we represent the update of our starting set `u` with \[[&exist;xPx]] as:
 
@@ -18,8 +29,8 @@
 
 	<pre><code>u updated with \[[&exist;x]] &equiv;
 		let extend one_dpm (d : entity) =
-			bind_dpm one_dpm (new_peg_and_assign 'x' d)
-		in bind_set u (fun one_dpm -> List.map (fun d -> extend one_dpm d) domain)
+			dpm_bind one_dpm (new_peg_and_assign 'x' d)
+		in set_bind u (fun one_dpm -> List.map (fun d -> extend one_dpm d) domain)
 	</code></pre>
 
 	where `new_peg_and_assign` is the operation we defined in [hint 3](/hints/assignment_7_hint_3):
@@ -47,18 +58,18 @@
 
 	or, being explicit about which "bind" operation we're representing here with `>>=`, that is:
 
-	<pre><code>bind_set (bind_set u \[[&exist;x]]) \[[Px]]
+	<pre><code>set_bind (set_bind u \[[&exist;x]]) \[[Px]]
 	</code></pre>
 
-*	Let's compare this to what \[[&exist;xPx]] would look like on a non-dynamic semantics, for example, where we use a simple reader monad to implement variable binding. Reminding ourselves, we'd be working in a framework like this. (Here we implement environments or assignments as functions from variables to entities, instead of as lists of pairs of variables and entities. An assignment `r` here is what `fun c -> List.assoc c r` would have been in [week6](
+*	Let's compare this to what \[[&exist;xPx]] would look like on a non-dynamic semantics, for example, where we use a simple Reader monad to implement variable binding. Reminding ourselves, we'd be working in a framework like this. (Here we implement environments or assignments as functions from variables to entities, instead of as lists of pairs of variables and entities. An assignment `r` here is what `fun c -> List.assoc c r` would have been in [week7](
 /reader_monad_for_variable_binding).)
  
 		type assignment = char -> entity;;
 		type 'a reader = assignment -> 'a;;
 
-		let unit_reader (value : 'a) : 'a reader = fun r -> value;;
+		let reader_unit (value : 'a) : 'a reader = fun r -> 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 r ->
 				let a = u r
 				in let u' = f a
@@ -78,7 +89,7 @@
 			fun entity_reader ->
 				fun r ->
 					let obj = entity_reader r
-					in unit_reader (predicate obj)
+					in reader_unit (predicate obj)
 
 	The meaning of \[[Qx]] would then be:
 
@@ -87,7 +98,7 @@
 	\[[Qx]] &equiv; \[[Q]] \[[x]] &equiv;
 		fun r ->
 			let obj = getx r
-			in unit_reader (q obj)
+			in reader_unit (q obj)
 	</code></pre>
 
 	Recall also how we defined \[[lambda x]], or as [we called it before](/reader_monad_for_variable_binding), \\[[who(x)]]:
@@ -104,11 +115,11 @@
 
 		fun (lifted_predicate : lifted_unary) ->
 			fun r -> exists (fun (obj : entity) ->
-				lifted_predicate (unit_reader obj) r)
+				lifted_predicate (reader_unit obj) r)
 			
 	That would be the meaning of \[[&exist;]], which we'd use like this:
 
-	<pre><code>\[[&exist;]] \[[Q]]
+	<pre><code>\[[&exist;]] ( \[[Q]] )
 	</code></pre>
 
 	or this:
@@ -125,7 +136,7 @@
 				in clause r'
 		in let lifted_exists =
 			fun lifted_predicate ->
-				fun r -> exists (fun obj -> lifted_predicate (unit_reader obj) r)
+				fun r -> exists (fun obj -> lifted_predicate (reader_unit obj) r)
 		in fun bool_reader -> lifted_exists (shift 'x' bool_reader)
 
 	which we can simplify to:
@@ -138,7 +149,7 @@
 				in clause r'
 		in let lifted_exists =
 			fun lifted_predicate ->
-				fun r -> exists (fun obj -> lifted_predicate (unit_reader obj) r)
+				fun r -> exists (fun obj -> lifted_predicate (reader_unit obj) r)
 		in fun bool_reader -> lifted_exists (shifted bool_reader)
 
 		fun bool_reader ->
@@ -147,11 +158,11 @@
 					let new_value = entity_reader r
 					in let r' = fun var -> if var = 'x' then new_value else r var
 					in bool_reader r'
-			in fun r -> exists (fun obj -> shifted' (unit_reader obj) r)
+			in fun r -> exists (fun obj -> shifted' (reader_unit obj) r)
 
 		fun bool_reader ->
 			let shifted'' r obj =
-					let new_value = (unit_reader obj) r
+					let new_value = (reader_unit obj) r
 					in let r' = fun var -> if var = 'x' then new_value else r var
 					in bool_reader r'
 			in fun r -> exists (fun obj -> shifted'' r obj)