For reminders about Scheme syntax, see [here](/assignment8/) and [here](/week1/) and [here](/translating_between_ocaml_scheme_and_haskell). Other resources are on our [[Learning Scheme]] page.
-All of the examples assume the following preface:
+Most of the examples assume the following preface:
#lang racket
[(null? l) (k 'notfound)]
[(eq? (car l) a) (cdr l)]
[(atom? (car l)) (cons (car l) (aux (cdr l) k))]
- ; what happens when (car l) exists but isn't an atom?
- [else (let ([car2 (let/cc k2 ; now what will happen when k2 is called?
- (aux (car l) k2))])
- (cond
- ; when will the following condition be met? what happens then?
- [(eq? car2 'notfound) (cons (car l) (aux (cdr l) k))]
- [else (cons car2 (cdr l))]))]))]
+ [else
+ ; what happens when (car l) exists but isn't an atom?
+ (let ([car2 (let/cc k2 ; now what will happen when k2 is called?
+ (aux (car l) k2))])
+ (cond
+ ; when will the following condition be met? what happens then?
+ [(eq? car2 'notfound) (cons (car l) (aux (cdr l) k))]
+ [else (cons car2 (cdr l))]))]))]
[lst2 (let/cc k1 ; now what will happen when k1 is called?
(aux lst k1))])
(cond
[(eq? lst2 'notfound) lst]
[else lst2]))))
-
Here is [the answer](/hints/cps_hint_3), but try to figure it out for yourself.
Here is the hardest example. Try to figure out what this function does:
Delimited control operators
===========================
+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.
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.