2012-07-16: Continuation Marks, part I: Dynamic Wind

One of my favourite features of Racket is also one of its most unique features: continuation marks.

Continuation marks allow you to annotate the dynamic context of a running program and later observe it to respond differently to your context.

In the next few posts, I’ll talk about continuation marks. But first, we need to cover a different feature of Racket called dynamic-wind. (Most people pronounce it like winding a winch, but I like to pronounce it like a gust of wind and say "Dynaaamic WIND!" as if it was a Street Fighter move.)

-

The classic example of continuation marks is a flow-sensitive variable, like the current indentation level of debugging printfs.

For example, suppose you have this program:

And with this example

You want it to print as:

One obvious way is to use a global variable:

The key is to reset the indentation level after the thunk returns.

However, this is not a robust technique in the presence of control effects. For example, if the code throws an exception than the reset will not occur.

So it prints as:

And every subsequent is off by three. The same problem occurs when continuations are captured and invoked.

Racket provides a feature called dynamic-wind that helps you write this mutation code safely with respect to control effects:

dynamic-wind takes three functions. The first gets called whenever the body is "entered", the second is the body and is just called once at the start, and the third is called whenever the body is exited. In normal situations, it is just like a sequence of three calls.

But, when control leaves the body somehow—like through an exception, abort, or continuation invocation—then the third function is called to "undo" whatever state changes were made when the body was entered.

Similarly, when control enters the body somehow—like when a continuation is captured inside the body and is invoked after the body has already returned—then the first function is called again to "redo" whatever state changes the body relies on.

Try to predict the output of these programs:

Example 1: Just a sequence of printfs.

Example 2: An equivalent sequence, but within dynamic-wind.

Example 3: An almost identical sequence, but now with an exception.

Example 4: Now we replace the raise with continuation capture and invoke the continuation.

Bonus question: Why doesn’t this code infinite loop?

Example 5: Now rather than using mutation, we communicate the continuation with an exception.

Example 6: Invoking the continuation repeatedly inside the exception handler.

Next week we’ll go on to how dynamic-wind relates to continuation marks.

And here is the expected output, by the way:

By the way, if you use this code at home, make sure you put the code in this order: