From: Jim Pryor <profjim@jimpryor.net>
Date: Mon, 13 Dec 2010 14:39:36 +0000 (-0500)
Subject: cps tweaks
X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=commitdiff_plain;h=62f467c824015512f41061fe2777dbc326649f5b

cps tweaks

Signed-off-by: Jim Pryor <profjim@jimpryor.net>
---

diff --git a/cps_and_continuation_operators.mdwn b/cps_and_continuation_operators.mdwn
index 7b302c67..3b0dda78 100644
--- a/cps_and_continuation_operators.mdwn
+++ b/cps_and_continuation_operators.mdwn
@@ -308,7 +308,7 @@ I set (2) aside a moment ago. The story we just told is a bit too simple because
 For instance, in Scheme this:
 
 	(require racket/control)
-
+	
 	(reset
 	 (let ([x 1])
 	   (+ 10 (shift k x))))
@@ -349,13 +349,13 @@ Using `shift` and `reset` operators in OCaml, this would look like this:
 	let reset = Delimcc.push_prompt p;;
 	let shift = Delimcc.shift p;;
 	let abort = Delimcc.abort p;;
-
+	
 	let foo x =
 	  reset(fun () ->
-		shift(fun continue ->
-			if x = 1 then continue 10
-			else 20
-		) + 100
+	    shift(fun continue ->
+	        if x = 1 then continue 10
+	        else 20
+	    ) + 100
 	  )
 	in foo 2 + 1000;;
 	- : int = 1020
@@ -402,38 +402,38 @@ Here are some more examples of using delimited control operators. We present eac
 Example 1:
 
 	; (+ 100 (+ 10 (abort 1))) ~~> 1
-
+	
 	app2 (op2 plus) (var hundred)
 	  (app2 (op2 plus) (var ten) (abort (var one)))
-
+	
 	# Continuation_monad.(run0(
-		abort 1 >>= fun i ->
+	    abort 1 >>= fun i ->
 	    unit (10+i) >>= fun j ->
-		unit (100+j)));;
+	    unit (100+j)));;
 	- : int = 1
 
 When no `reset` is specified, there's understood to be an implicit one surrounding the entire computation (but unlike in the case of `callcc`, you still can't capture up to *and including* the end of the computation). So it makes no difference if we say instead:
 
 	# Continuation_monad.(run0(
-		reset (
-		  abort 1 >>= fun i ->
-		  unit (10+i) >>= fun j ->
-		  unit (100+j))));;
+	    reset (
+	      abort 1 >>= fun i ->
+	      unit (10+i) >>= fun j ->
+	      unit (100+j))));;
 	- : int = 1
 
 
 Example 2:
 	
 	; (+ 100 (reset (+ 10 (abort 1)))) ~~> 101
-
+	
 	app2 (op2 plus) (var hundred)
 	  (reset (app2 (op2 plus) (var ten) (abort (var one))))
-
+	
 	# Continuation_monad.(run0(
-		reset (
-		  abort 1 >>= fun i ->
-		  unit (10+i)) >>= fun j ->
-		   unit (100+j)));;
+	    reset (
+	      abort 1 >>= fun i ->
+	      unit (10+i)) >>= fun j ->
+	       unit (100+j)));;
 	- : int = 101
 
 Example 3:
@@ -442,29 +442,31 @@ Example 3:
 
 	app2 (op2 plus) (var thousand)
 	  (reset (app2 (op2 plus) (var hundred)
-		(shift (\k. ((op2 plus) (var ten) (var one))))))
+	    (shift (\k. ((op2 plus) (var ten) (var one))))))
 
 	Continuation_monad.(
-		let v = reset (
-		  let u = shift (fun k -> unit (10 + 1))
-		  in u >>= fun x -> unit (100 + x)
-		) in let w = v >>= fun x -> unit (1000 + x)
-		in run0 w)
+	  let v = reset (
+	    let u = shift (fun k -> unit (10 + 1))
+	    in u >>= fun x -> unit (100 + x)
+	  ) in let w = v >>= fun x -> unit (1000 + x)
+	  in run0 w);;
+	- : int = 1011
 
 Example 4:
 
 	; (+ 1000 (reset (+ 100 (shift k (k (+ 10 1)))))) ~~> 1111
-
+	
 	app2 (op2 plus) (var thousand)
 	  (reset (app2 (op2 plus) (var hundred)
-		(shift (\k. (app (var k) ((op2 plus) (var ten) (var one)))))))
-
+	    (shift (\k. (app (var k) ((op2 plus) (var ten) (var one)))))))
+	
 	Continuation_monad.(
 	  let v = reset (
 	    let u = shift (fun k -> k (10 :: [1]))
-		in u >>= fun x -> unit (100 :: x)
+	    in u >>= fun x -> unit (100 :: x)
 	  ) in let w = v >>= fun x -> unit (1000 :: x)
-      in run0 w)
+	  in run0 w);;
+	- : int list = [1000; 100; 10; 1]
 
 To demonstrate the different adding order between Examples 4 and 5, we use `::` in the OCaml version instead of `+`. Here is Example 5:
 
@@ -472,37 +474,40 @@ To demonstrate the different adding order between Examples 4 and 5, we use `::`
 
 	app2 (op2 plus) (var thousand)
 	  (reset (app2 (op2 plus) (var hundred)
-		(shift (\k. ((op2 plus) (var ten) (app (var k) (var one)))))))
+	    (shift (\k. ((op2 plus) (var ten) (app (var k) (var one)))))))
+	
+	Continuation_monad.(let v = reset (
+	  let u = shift (fun k -> k [1] >>= fun x -> unit (10 :: x))
+	    in u >>= fun x -> unit (100 :: x)
+	  ) in let w = v >>= fun x -> unit (1000 :: x)
+	  in run0  w)
+	- : int list = [1000; 10; 100; 1]
 
-	  Continuation_monad.(let v = reset (
-		  let u = shift (fun k -> k [1] >>= fun x -> unit (10 :: x))
-		  in u >>= fun x -> unit (100 :: x)
-		) in let w = v >>= fun x -> unit (1000 :: x)
-		in run0  w)
 
 Example 6:
 
 	; (+ 100 ((reset (+ 10 (shift k k))) 1)) ~~> 111
-
+	
 	app2 (op2 plus) (var hundred)
 	  (app (reset (app2 (op2 plus) (var ten)
-		(shift (\k. (var k))))) (var one))
-
+	    (shift (\k. (var k))))) (var one))
+	
 	(* not sure if this example can be typed as-is in OCaml. We may need a sum-type *)
 
 Example 7:
 
 	; (+ 100 (reset (+ 10 (shift k (k (k 1)))))) ~~> 121
-
+	
 	app2 (op2 plus) (var hundred)
 	  (reset (app2 (op2 plus) (var ten)
-		(shift (\k. app (var k) (app (var k) (var one))))))
-
+	    (shift (\k. app (var k) (app (var k) (var one))))))
+	
 	Continuation_monad.(let v = reset (
 	  let u = shift (fun k -> k 1 >>= fun x -> k x)
 	    in u >>= fun x -> unit (10 + x)
 	  ) in let w = v >>= fun x -> unit (100 + x)
 	  in run0 w)
+	- : int = 121
 
 <!--