X-Git-Url: http://lambda.jimpryor.net/git/gitweb.cgi?p=lambda.git;a=blobdiff_plain;f=cps_and_continuation_operators.mdwn;h=aa2900c8b0012b553ff6e705ace9c6041b40892b;hp=1ddcf37d7f3c383c8aee8a9c2ddad012f198dd8c;hb=333924dc64733882d990c740fba395ae87185ad8;hpb=bf26430df156fa887f9d6f241474a628a3e12d8e

diff --git a/cps_and_continuation_operators.mdwn b/cps_and_continuation_operators.mdwn
index 1ddcf37d..aa2900c8 100644
--- a/cps_and_continuation_operators.mdwn
+++ b/cps_and_continuation_operators.mdwn
@@ -401,11 +401,9 @@ Here again is the CPS for `callcc`:
 
  	[callcc (\k. body)] = \outk. (\k. [body] outk) (\v localk. outk v)
 
-`callcc` is what's known as an *undelimited control operator*. That is, the continuations `outk` that get bound to our `k`s behave as though they include all the code from the `call/cc ...` out to *and including* the end of the program.
+`callcc` is what's known as an *undelimited control operator*. That is, the continuations `outk` that get bound into our `k`s include all the code from the `call/cc ...` out to *and including* the end of the program. Calling such a continuation will never return any value to the call site. (See the technique employed in the `delta` example above, with the `(begin (let/cc k2 ...) ...)`, for a work-around.)
 
-Often times it's more useful to use a different pattern, where we instead capture only the code from the invocation of our control operator out to a certain boundary, not including the end of the program. These are called *delimited control operators*. A variety of the latter have been formulated.
-
-The most well-behaved from where we're coming from is the pair `reset` and `shift`. `reset` sets the boundary, and `shift` binds the continuation from the position where it's invoked out to that boundary.
+Often times it's more useful to use a different pattern, where we instead capture only the code from the invocation of our control operator out to a certain boundary, not including the end of the program. These are called *delimited control operators*. A variety of these have been formulated. The most well-behaved from where we're coming from is the pair `reset` and `shift`. `reset` sets the boundary, and `shift` binds the continuation from the position where it's invoked out to that boundary.
 
 It works like this:
 
@@ -486,7 +484,7 @@ If instead at the end we did `... foo 1 + 1000`, we'd get the result `1110`.
 
 The above OCaml code won't work out of the box; you have to compile and install a special library that Oleg wrote. We discuss it on our [translation page](/translating_between_ocaml_scheme_and_haskell). If you can't get it working, then you can play around with `shift` and `reset` in Scheme instead. Or in the Continuation monad. Or using CPS transforms of your code, with the help of the lambda evaluator.
 
-The relevant CPS transforms will be performed by these helper functions:
+You can make the lambda evaluator perform the required CPS transforms with these helper functions:
 
 	let reset = \body. \outk. outk (body (\i i)) in
 	let shift = \k_body. \midk. (\k. (k_body k) (\i i)) (\a localk. localk (midk a)) in