Class 10: Continuations, Nearly Concluded

Held Monday, February 15

Summary

• Reading: Louden, Chapter 12

Contents

Notes

• Any questions on the exam?
• Quiz 1 returned. As I mentioned on Friday, most of you got the first problem, but not the second. A correct answer to both halves gave you two units of extra credit (there is not yet a mapping between units and points). A correct answer to one half gave you one unit of extra credit. A partial answer to one half gave you 1/2 unit.
• Assignment 2 returned. I only graded the second problem (dealing with infinite lists). Most of you benefited from this grading scheme.
  • Notes on the assignment are now available. Note that there are some suggestions for extra credit.
• Thursday at 4:15 is a cool statistics talk.

Assignment 2

There are a number of issues that we need to discuss pertaining to assignment 2.

Code Reuse

It's fine if you copy code from elsewhere, provided you

• cite it and
• comment it

Many of you copied code from Mr. Walker and Mr. Stone. While their code did not have comments, it was typically preceded by a few pages of narrative comments. I don't want the narrative comments, I want in-code comments.

Misuse of if

I saw things like the following in too many assignments.

(if (test) #t #f)
(if (test) #f #t)

• The first is a less-clear version of (test)
• The second is a less-clear version of (not (test))

Wasted Work

On a similar note, what is the point of things like the following?

(+ x 0)
(* x 1)

Testing

Most of your sorts? predicates were awful. First of all, many of you assumed that a method sorts a particular list correctly if it returns a sorted list. Under that criterion, the following method sorts correctly.

(define (sort l)
  '(1 2 3))

How should you have tested your sorting methods? The earlier parts of part A (as well as the introduction) should have given you a clue. Start with a few sorted lists. Generate permutations of those sorted lists. Try sorting those permutations. If each sorted permutation is the same as the original list, then it seems that the sorting mechanism works.

Oh No! More Continuations

Call/CC

• In addition to supporting continuation-passing-style (as, presumably, all functional languages with lambda abstraction do), Scheme also keeps track of the implicit continuations.
• At any point, you can call a function with the current continuation using

  (call-with-current-continuation cpsfun)
  

• Because that name is so long, most implementations of Scheme tend to support call/cc.
• Note that the inclusion of such a function creates some significant implications for implementers. In order to keep track of the current continuation, the compiler will typically translate every program into one in continuation-passing-style.

Breakpoints

This discussion is based on some notes by folks at Oberlin and Essentials of Programming Languages by Friedman, Wand, and Haynes.

• Note that whenever you call a continuation created by call/cc it replaces the current continuation.
• This means that it is useful for changing the execution flow of a program.
• Continuations and call/cc provide a useful framework for creating an interesting break/resume structure.
• First, we need to be able to grab the ``top level'' continuation (the read-eval-print loop). Note that set! is a side-effecting assignment operator.

  (call/cc (lambda (y)
     (set! top y)))
  

• Next, we define a break function that grabs the current context (the context in which break was called), stores that context as a method, resume, prints a message, and then uses the top-level context to stop execution.

  (define break
    (lambda (x)
       (call/cc (lambda (k)	; What will be done with x?
          (begin
             (set! resume k)	; Remember what to do
             (display "Break!  Use (resume val) to continue.  ");
             (display "Last value was: ");
             (top x)		; Exit!
          ) ; begin
          ) ; lambda(k)
       ) ; call/cc
    ) ; lambda (x)
  ) ; define break
  

• We can then execute some expressions, stopping as we go.

  > (+ (* (break 1) 2) (- 17 (break 3))))
  Break!  Use (resume val) to continue.  Last value was: 3
  > (resume 3)
  Break!  Use (resume val) to continue.  Last value was: 1
  > (resume 1)
  16
  > (+ (break (* (break 2) (break 3)))
       (break (- (break 4) (break 5))))
  Break!  Use (resume val) to continue.  Last value was: 5
  > (resume 5)
  Break!  Use (resume val) to continue.  Last value was: 4
  > (resume 4)
  Break!  Use (resume val) to continue.  Last value was: -1
  > (resume -1)
  Break!  Use (resume val) to continue.  Last value was: 3
  > (resume 3)
  Break!  Use (resume val) to continue.  Last value was: 2
  > (resume 2)
  Break!  Use (resume val) to continue.  Last value was: 6
  > (resume 6)
  5
  > (+ (break (* (break 2) (break 3)))
       (break (- (break 4) (break 5))))
  Break!  Use (resume val) to continue.  Last value was: 5
  > (resume 10) ; Look, we're substituting a different value.
  Break!  Use (resume val) to continue.  Last value was: 4
  > (resume 4)
  Break!  Use (resume val) to continue.  Last value was: -6
  

• Try it yourself (we'll take about a ten-minute break for experimentation).
  • Try the examples above.
  • What happens if you resume with an expression that includes break?

Other Uses

• Continuations are also use for implementing coroutines. Coroutines are pairs of procedures in which you alternate portions of the procedures.
  • Typically, when one procedure calls another, the second must terminate before the first can resume.
  • Using coroutines, the second can also interrupt itself and return to the control flow of the first.
• Coroutines provide one mechanism for modeling cooperating processes.
• Think about how you might use continuations to implement coroutines.

• You might find it possible to use continuations to implement something close to exceptions (if you don't know what an exception is, don't worry).
  • In effect, you pass in the exception handler(s) and the method calls the appropriate handler.
  • If the handler is a ``true'' continuation, it really does change the flow of control.

• I'll admit that continuations are kind-of-like quantum mechanics: while many people can understand the basic concepts, it takes a particular type of mind to really ``grok'' them.

History

• Created Tuesday, January 19, 1999 as a blank outline.
• Filled in the details on Monday, February 15, 1999.
• Removed uncovered material on Wednesday, February 17, 1999.