Delimited continuation
Continuation that returns a value
- 25 min read
- 3 chapters
Related on Lably
Through Function (computer programming), Pattern matching and Scheme (programming language)
History
Delimited continuations were first introduced by Felleisen in 1988 with an operator called , first introduced in a tech report in 1987, along with a prompt construct . The operator was designed to be a generalization of control operators that had been described in the literature such as call/cc from Scheme, ISWIM's J operator, John C. Reynolds' escape operator, and others. Subsequently, many competing delimited control operators were invented by the programming languages research community such as prompt and control, shift and reset,cupto, fcontrol, and others.
Sign in to keep reading
2 more chapters are free with a Lably account.
Examples
Various operators for delimited continuations have been proposed in the research literature.
One independent proposal is based on continuation-passing style (CPS)—i.e., not on continuation frames—and offers two control operators, shift and reset, that give rise to static rather than to dynamic delimited continuations. The reset operator sets the limit for the continuation while the shift operator captures or reifies the current continuation up to the innermost enclosing reset. For example, consider the following snippet in Scheme:
<span id="mwZA"></span><span class="p" id="mwZQ">(</span><span class="nb" id="mwZg">*</span><span class="w" id="mwZw"> </span><span class="mi" id="mwaA">2</span><span class="w" id="mwaQ"> </span><span class="p" id="mwag">(</span><span class="nf" id="mwaw">reset</span><span class="w" id="mwbA"> </span><span class="p" id="mwbQ">(</span><span class="nb" id="mwbg">+</span><span class="w" id="mwbw"> </span><span class="mi" id="mwcA">1</span><span class="w" id="mwcQ"> </span><span class="p" id="mwcg">(</span><span class="nf" id="mwcw">shift</span><span class="w" id="mwdA"> </span><span class="nv" id="mwdQ">k</span><span class="w" id="mwdg"> </span><span class="p" id="mwdw">(</span><span class="nf" id="mweA">k</span><span class="w" id="mweQ"> </span><span class="mi" id="mweg">5</span><span class="p" id="mwew">)))))</span>
The reset delimits the continuation that shift captures (named by k in this example). When this snippet is executed, the use of shift will bind k to the continuation (+ 1 []) where [] represents the part of the computation that is to be filled with a value. This continuation directly corresponds to the code that surrounds the shift up to the reset. Because the body of shift (i.e., (k 5)) immediately invokes the continuation, this code is equivalent to the following:
<span id="mwiQ"></span><span class="p" id="mwig">(</span><span class="nb" id="mwiw">*</span><span class="w" id="mwjA"> </span><span class="mi" id="mwjQ">2</span><span class="w" id="mwjg"> </span><span class="p" id="mwjw">(</span><span class="nb" id="mwkA">+</span><span class="w" id="mwkQ"> </span><span class="mi" id="mwkg">1</span><span class="w" id="mwkw"> </span><span class="mi" id="mwlA">5</span><span class="p" id="mwlQ">))</span>
In general, these operators can encode more interesting behavior by, for example, returning the captured continuation k as a value or invoking k multiple times. The shift operator passes the captured continuation k to the code in its body, which can either invoke it, produce it as a result, or ignore it entirely. Whatever result that shift produces is provided to the innermost reset, discarding the continuation in between the reset and shift. However, if the continuation is invoked, then it effectively re-installs the continuation after returning to the reset. When the entire computation within reset is completed, the result is returned by the delimited continuation. For example, in this Scheme code:
<span id="mwqA"></span><span class="w" id="mwqQ"> </span><span class="p" id="mwqg">(</span><span class="nf" id="mwqw">reset</span><span class="w" id="mwrA"> </span><span class="p" id="mwrQ">(</span><span class="nb" id="mwrg">*</span><span class="w" id="mwrw"> </span><span class="mi" id="mwsA">2</span><span class="w" id="mwsQ"> </span><span class="p" id="mwsg">(</span><span class="nf" id="mwsw">shift</span><span class="w" id="mwtA"> </span><span class="nv" id="mwtQ">k</span><span class="w" id="mwtg"> </span><span class="nv" id="mwtw">CODE</span><span class="p" id="mwuA">)))</span>
whenever CODE invokes (k N), (* 2 N) is evaluated and returned.
This is equivalent to the following:
<span id="mwwA"></span><span class="w" id="mwwQ"> </span><span class="p" id="mwwg">(</span><span class="k" id="mwww">let</span><span class="w" id="mwxA"> </span><span class="p" id="mwxQ">((</span><span class="nf" id="mwxg">k</span><span class="w" id="mwxw"> </span><span class="p" id="mwyA">(</span><span class="k" id="mwyQ">lambda</span><span class="w" id="mwyg"> </span><span class="p" id="mwyw">(</span><span class="nf" id="mwzA">x</span><span class="p" id="mwzQ">)</span><span class="w" id="mwzg"> </span><span class="p" id="mwzw">(</span><span class="nb" id="mw0A">*</span><span class="w" id="mw0Q"> </span><span class="mi" id="mw0g">2</span><span class="w" id="mw0w"> </span><span class="nv" id="mw1A">x</span><span class="p" id="mw1Q">))))</span><span class="w" id="mw1g"> </span><span class="nv" id="mw1w">CODE</span><span class="p" id="mw2A">)</span>
Furthermore, once the entire computation within shift is completed, the continuation is discarded, and execution restarts outside reset. Therefore,
<span id="mw3g"></span><span class="w" id="mw3w"> </span><span class="p" id="mw4A">(</span><span class="nf" id="mw4Q">reset</span><span class="w" id="mw4g"> </span><span class="p" id="mw4w">(</span><span class="nb" id="mw5A">*</span><span class="w" id="mw5Q"> </span><span class="mi" id="mw5g">2</span><span class="w" id="mw5w"> </span><span class="p" id="mw6A">(</span><span class="nf" id="mw6Q">shift</span><span class="w" id="mw6g"> </span><span class="nv" id="mw6w">k</span><span class="w" id="mw7A"> </span><span class="p" id="mw7Q">(</span><span class="nf" id="mw7g">k</span><span class="w" id="mw7w"> </span><span class="p" id="mw8A">(</span><span class="nf" id="mw8Q">k</span><span class="w" id="mw8g"> </span><span class="mi" id="mw8w">4</span><span class="p" id="mw9A">)))))</span>
invokes (k 4) first (which returns 8), and then (k 8) (which returns 16). At this point, the shift expression has terminated, and the rest of the reset expression is discarded. Therefore, the final result is 16.
Everything that happens outside the reset expression is hidden, i.e. not influenced by the control transfer. For example, this returns 17:
<span id="mw_g"></span><span class="w" id="mw_w"> </span><span class="p" id="mwAQA">(</span><span class="nb" id="mwAQE">+</span><span class="w" id="mwAQI"> </span><span class="mi" id="mwAQM">1</span><span class="w" id="mwAQQ"> </span><span class="p" id="mwAQU">(</span><span class="nf" id="mwAQY">reset</span><span class="w" id="mwAQc"> </span><span class="p" id="mwAQg">(</span><span class="nb" id="mwAQk">*</span><span class="w" id="mwAQo"> </span><span class="mi" id="mwAQs">2</span><span class="w" id="mwAQw"> </span><span class="p" id="mwAQ0">(</span><span class="nf" id="mwAQ4">shift</span><span class="w" id="mwAQ8"> </span><span class="nv" id="mwARA">k</span><span class="w" id="mwARE"> </span><span class="p" id="mwARI">(</span><span class="nf" id="mwARM">k</span><span class="w" id="mwARQ"> </span><span class="p" id="mwARU">(</span><span class="nf" id="mwARY">k</span><span class="w" id="mwARc"> </span><span class="mi" id="mwARg">4</span><span class="p" id="mwARk">))))))</span>
Delimited continuations were first described independently by Felleisen et al. and Johnson. They have since been used in a large number of domains, particularly in defining new control operators; see Queinnec for a survey.
Let's take a look at a more complicated example. Let null be the empty list:
<span id="mwAS0"></span><span class="w" id="mwAS4"> </span><span class="p" id="mwAS8">(</span><span class="nf" id="mwATA">reset</span> <span class="w" id="mwATE"> </span><span class="p" id="mwATI">(</span><span class="k" id="mwATM">begin</span> <span class="w" id="mwATQ"> </span><span class="p" id="mwATU">(</span><span class="nf" id="mwATY">shift</span><span class="w" id="mwATc"> </span><span class="nv" id="mwATg">k</span><span class="w" id="mwATk"> </span><span class="p" id="mwATo">(</span><span class="nb" id="mwATs">cons</span><span class="w" id="mwATw"> </span><span class="mi" id="mwAT0">1</span><span class="w" id="mwAT4"> </span><span class="p" id="mwAT8">(</span><span class="nf" id="mwAUA">k</span><span class="w" id="mwAUE"> </span><span class="p" id="mwAUI">(</span><span class="nf" id="mwAUM">void</span><span class="p" id="mwAUQ">))))</span><span class="w" id="mwAUU"> </span><span class="c1" id="mwAUY">;; (1)</span> <span class="w" id="mwAUc"> </span><span class="nv" id="mwAUg">null</span><span class="p" id="mwAUk">))</span>
The context captured by shift is (begin [*] null), where [*] is the hole where k's parameter will be injected. The first call of k inside shift evaluates to this context with (void) = #<void> replacing the hole, so the value of (k (void)) is (begin #<void> null) = null. The body of shift, namely (cons 1 null) = (1), becomes the overall value of the reset expression as the final result.
Making this example more complicated, add a line:
<span id="mwAV0"></span><span class="w" id="mwAV4"> </span><span class="p" id="mwAV8">(</span><span class="nf" id="mwAWA">reset</span> <span class="w" id="mwAWE"> </span><span class="p" id="mwAWI">(</span><span class="k" id="mwAWM">begin</span> <span class="w" id="mwAWQ"> </span><span class="p" id="mwAWU">(</span><span class="nf" id="mwAWY">shift</span><span class="w" id="mwAWc"> </span><span class="nv" id="mwAWg">k</span><span class="w" id="mwAWk"> </span><span class="p" id="mwAWo">(</span><span class="nb" id="mwAWs">cons</span><span class="w" id="mwAWw"> </span><span class="mi" id="mwAW0">1</span><span class="w" id="mwAW4"> </span><span class="p" id="mwAW8">(</span><span class="nf" id="mwAXA">k</span><span class="w" id="mwAXE"> </span><span class="p" id="mwAXI">(</span><span class="nf" id="mwAXM">void</span><span class="p" id="mwAXQ">))))</span> <span class="w" id="mwAXU"> </span><span class="p" id="mwAXY">(</span><span class="nf" id="mwAXc">shift</span><span class="w" id="mwAXg"> </span><span class="nv" id="mwAXk">k</span><span class="w" id="mwAXo"> </span><span class="p" id="mwAXs">(</span><span class="nb" id="mwAXw">cons</span><span class="w" id="mwAX0"> </span><span class="mi" id="mwAX4">2</span><span class="w" id="mwAX8"> </span><span class="p" id="mwAYA">(</span><span class="nf" id="mwAYE">k</span><span class="w" id="mwAYI"> </span><span class="p" id="mwAYM">(</span><span class="nf" id="mwAYQ">void</span><span class="p" id="mwAYU">))))</span> <span class="w" id="mwAYY"> </span><span class="nv" id="mwAYc">null</span><span class="p" id="mwAYg">))</span>
If we comment out the first shift, we already know the result, it is (2); so we can as well rewrite the expression like this:
<span id="mwAY4"></span><span class="w" id="mwAY8"> </span><span class="p" id="mwAZA">(</span><span class="nf" id="mwAZE">reset</span> <span class="w" id="mwAZI"> </span><span class="p" id="mwAZM">(</span><span class="k" id="mwAZQ">begin</span> <span class="w" id="mwAZU"> </span><span class="p" id="mwAZY">(</span><span class="nf" id="mwAZc">shift</span><span class="w" id="mwAZg"> </span><span class="nv" id="mwAZk">k</span><span class="w" id="mwAZo"> </span><span class="p" id="mwAZs">(</span><span class="nb" id="mwAZw">cons</span><span class="w" id="mwAZ0"> </span><span class="mi" id="mwAZ4">1</span><span class="w" id="mwAZ8"> </span><span class="p" id="mwAaA">(</span><span class="nf" id="mwAaE">k</span><span class="w" id="mwAaI"> </span><span class="p" id="mwAaM">(</span><span class="nf" id="mwAaQ">void</span><span class="p" id="mwAaU">))))</span> <span class="w" id="mwAaY"> </span><span class="p" id="mwAac">(</span><span class="nb" id="mwAag">list</span><span class="w" id="mwAak"> </span><span class="mi" id="mwAao">2</span><span class="p" id="mwAas">)))</span>
This is pretty familiar, and can be rewritten as (cons 1 (list 2)), that is, (list 1 2).
We can define yield using this trick:
(define (yield x) (shift k (cons x (k (void)))))
and use it in building lists:
<span id="mwAbU"></span><span class="w" id="mwAbY"> </span><span class="p" id="mwAbc">(</span><span class="nf" id="mwAbg">reset</span><span class="w" id="mwAbk"> </span><span class="p" id="mwAbo">(</span><span class="k" id="mwAbs">begin</span> <span class="w" id="mwAbw"> </span><span class="p" id="mwAb0">(</span><span class="nf" id="mwAb4">yield</span><span class="w" id="mwAb8"> </span><span class="mi" id="mwAcA">1</span><span class="p" id="mwAcE">)</span> <span class="w" id="mwAcI"> </span><span class="p" id="mwAcM">(</span><span class="nf" id="mwAcQ">yield</span><span class="w" id="mwAcU"> </span><span class="mi" id="mwAcY">2</span><span class="p" id="mwAcc">)</span> <span class="w" id="mwAcg"> </span><span class="p" id="mwAck">(</span><span class="nf" id="mwAco">yield</span><span class="w" id="mwAcs"> </span><span class="mi" id="mwAcw">3</span><span class="p" id="mwAc0">)</span> <span class="w" id="mwAc4"> </span><span class="nv" id="mwAc8">null</span><span class="p" id="mwAdA">))</span><span class="w" id="mwAdE"> </span><span class="c1" id="mwAdI">;; (list 1 2 3)</span>
If we replace cons with stream-cons, we can build lazy streams:
<span id="mwAdg"></span><span class="w" id="mwAdk"> </span><span class="p" id="mwAdo">(</span><span class="k" id="mwAds">define</span><span class="w" id="mwAdw"> </span><span class="p" id="mwAd0">(</span><span class="nf" id="mwAd4">stream-yield</span><span class="w" id="mwAd8"> </span><span class="nv" id="mwAeA">x</span><span class="p" id="mwAeE">)</span><span class="w" id="mwAeI"> </span><span class="p" id="mwAeM">(</span><span class="nf" id="mwAeQ">shift</span><span class="w" id="mwAeU"> </span><span class="nv" id="mwAeY">k</span><span class="w" id="mwAec"> </span><span class="p" id="mwAeg">(</span><span class="nf" id="mwAek">stream-cons</span><span class="w" id="mwAeo"> </span><span class="nv" id="mwAes">x</span><span class="w" id="mwAew"> </span><span class="p" id="mwAe0">(</span><span class="nf" id="mwAe4">k</span><span class="w" id="mwAe8"> </span><span class="p" id="mwAfA">(</span><span class="nf" id="mwAfE">void</span><span class="p" id="mwAfI">)))))</span> <span class="w" id="mwAfM"> </span><span class="p" id="mwAfQ">(</span><span class="k" id="mwAfU">define</span><span class="w" id="mwAfY"> </span><span class="nv" id="mwAfc">lazy-example</span> <span class="w" id="mwAfg"> </span><span class="p" id="mwAfk">(</span><span class="nf" id="mwAfo">reset</span><span class="w" id="mwAfs"> </span><span class="p" id="mwAfw">(</span><span class="k" id="mwAf0">begin</span> <span class="w" id="mwAf4"> </span><span class="p" id="mwAf8">(</span><span class="nf" id="mwAgA">stream-yield</span><span class="w" id="mwAgE"> </span><span class="mi" id="mwAgI">1</span><span class="p" id="mwAgM">)</span> <span class="w" id="mwAgQ"> </span><span class="p" id="mwAgU">(</span><span class="nf" id="mwAgY">stream-yield</span><span class="w" id="mwAgc"> </span><span class="mi" id="mwAgg">2</span><span class="p" id="mwAgk">)</span> <span class="w" id="mwAgo"> </span><span class="p" id="mwAgs">(</span><span class="nf" id="mwAgw">stream-yield</span><span class="w" id="mwAg0"> </span><span class="mi" id="mwAg4">3</span><span class="p" id="mwAg8">)</span> <span class="w" id="mwAhA"> </span><span class="nv" id="mwAhE">stream-null</span><span class="p" id="mwAhI">)))</span>
We can generalize this and convert lists to stream, in one fell swoop:
<span id="mwAhY"></span><span class="w" id="mwAhc"> </span><span class="p" id="mwAhg">(</span><span class="k" id="mwAhk">define</span><span class="w" id="mwAho"> </span><span class="p" id="mwAhs">(</span><span class="nf" id="mwAhw">list->stream</span><span class="w" id="mwAh0"> </span><span class="nv" id="mwAh4">xs</span><span class="p" id="mwAh8">)</span> <span class="w" id="mwAiA"> </span><span class="p" id="mwAiE">(</span><span class="nf" id="mwAiI">reset</span><span class="w" id="mwAiM"> </span><span class="p" id="mwAiQ">(</span><span class="k" id="mwAiU">begin</span> <span class="w" id="mwAiY"> </span><span class="p" id="mwAic">(</span><span class="nb" id="mwAig">for-each</span><span class="w" id="mwAik"> </span><span class="nv" id="mwAio">stream-yield</span><span class="w" id="mwAis"> </span><span class="nv" id="mwAiw">xs</span><span class="p" id="mwAi0">)</span> <span class="w" id="mwAi4"> </span><span class="nv" id="mwAi8">stream-null</span><span class="p" id="mwAjA">)))</span>
In a more complicated example below the continuation can be safely wrapped into a body of a lambda, and be used as such:
<span id="mwAjQ"></span><span class="w" id="mwAjU"> </span><span class="p" id="mwAjY">(</span><span class="k" id="mwAjc">define</span><span class="w" id="mwAjg"> </span><span class="p" id="mwAjk">(</span><span class="nf" id="mwAjo">for-each->stream-maker</span><span class="w" id="mwAjs"> </span><span class="nb" id="mwAjw">for-each</span><span class="p" id="mwAj0">)</span><span class="w" id="mwAj4"> </span> <span class="w" id="mwAj8"> </span><span class="p" id="mwAkA">(</span><span class="k" id="mwAkE">lambda</span><span class="w" id="mwAkI"> </span><span class="p" id="mwAkM">(</span><span class="nf" id="mwAkQ">collection</span><span class="p" id="mwAkU">)</span><span class="w" id="mwAkY"> </span> <span class="w" id="mwAkc"> </span><span class="p" id="mwAkg">(</span><span class="nf" id="mwAkk">reset</span><span class="w" id="mwAko"> </span><span class="p" id="mwAks">(</span><span class="k" id="mwAkw">begin</span><span class="w" id="mwAk0"> </span> <span class="w" id="mwAk4"> </span><span class="p" id="mwAk8">(</span><span class="nb" id="mwAlA">for-each</span><span class="w" id="mwAlE"> </span><span class="p" id="mwAlI">(</span><span class="k" id="mwAlM">lambda</span><span class="w" id="mwAlQ"> </span><span class="p" id="mwAlU">(</span><span class="nf" id="mwAlY">element</span><span class="p" id="mwAlc">)</span><span class="w" id="mwAlg"> </span> <span class="w" id="mwAlk"> </span><span class="p" id="mwAlo">(</span><span class="nf" id="mwAls">shift</span><span class="w" id="mwAlw"> </span><span class="nv" id="mwAl0">k</span><span class="w" id="mwAl4"> </span> <span class="w" id="mwAl8"> </span><span class="p" id="mwAmA">(</span><span class="nf" id="mwAmE">stream-cons</span><span class="w" id="mwAmI"> </span><span class="nv" id="mwAmM">element</span><span class="w" id="mwAmQ"> </span><span class="p" id="mwAmU">(</span><span class="nf" id="mwAmY">k</span><span class="w" id="mwAmc"> </span><span class="ss" id="mwAmg">'ignored</span><span class="p" id="mwAmk">))))</span><span class="w" id="mwAmo"> </span> <span class="w" id="mwAms"> </span><span class="nv" id="mwAmw">collection</span><span class="p" id="mwAm0">)</span><span class="w" id="mwAm4"> </span> <span class="w" id="mwAm8"> </span><span class="nv" id="mwAnA">stream-null</span><span class="p" id="mwAnE">))))</span>
The part between reset and shift includes control functions like lambda and for-each; this is impossible to rephrase using lambdas.
Delimited continuations are also useful in linguistics: see Continuations in linguistics for details.
A worked-out illustration of the (shift k k) idiom: the generalized curry function
The generalized curry function is given an uncurried function f and its arity (say, 3), and it returns the value of (lambda (v1) (lambda (v2) (lambda (v3) (f v1 v2 v3)))). This example is due to Olivier Danvy and was worked out in the mid-1980s.
Here is a unit-test function to illustrate what the generalized curry function is expected to do:
<span id="mwAoo"></span><span class="p" id="mwAos">(</span><span class="k" id="mwAow">define</span><span class="w" id="mwAo0"> </span><span class="nv" id="mwAo4">test-curry</span> <span class="w" id="mwAo8"> </span><span class="p" id="mwApA">(</span><span class="k" id="mwApE">lambda</span><span class="w" id="mwApI"> </span><span class="p" id="mwApM">(</span><span class="nf" id="mwApQ">candidate</span><span class="p" id="mwApU">)</span> <span class="w" id="mwApY"> </span><span class="p" id="mwApc">(</span><span class="k" id="mwApg">and</span><span class="w" id="mwApk"> </span><span class="p" id="mwApo">(</span><span class="nb" id="mwAps">=</span><span class="w" id="mwApw"> </span><span class="p" id="mwAp0">(</span><span class="nf" id="mwAp4">candidate</span><span class="w" id="mwAp8"> </span><span class="nb" id="mwAqA">+</span><span class="w" id="mwAqE"> </span><span class="mi" id="mwAqI">0</span><span class="p" id="mwAqM">)</span> <span class="w" id="mwAqQ"> </span><span class="p" id="mwAqU">(</span><span class="nb" id="mwAqY">+</span><span class="p" id="mwAqc">))</span> <span class="w" id="mwAqg"> </span><span class="p" id="mwAqk">(</span><span class="nb" id="mwAqo">=</span><span class="w" id="mwAqs"> </span><span class="p" id="mwAqw">((</span><span class="nf" id="mwAq0">candidate</span><span class="w" id="mwAq4"> </span><span class="nb" id="mwAq8">+</span><span class="w" id="mwArA"> </span><span class="mi" id="mwArE">1</span><span class="p" id="mwArI">)</span><span class="w" id="mwArM"> </span><span class="mi" id="mwArQ">1</span><span class="p" id="mwArU">)</span> <span class="w" id="mwArY"> </span><span class="p" id="mwArc">(</span><span class="nb" id="mwArg">+</span><span class="w" id="mwArk"> </span><span class="mi" id="mwAro">1</span><span class="p" id="mwArs">))</span> <span class="w" id="mwArw"> </span><span class="p" id="mwAr0">(</span><span class="nb" id="mwAr4">=</span><span class="w" id="mwAr8"> </span><span class="p" id="mwAsA">(((</span><span class="nf" id="mwAsE">candidate</span><span class="w" id="mwAsI"> </span><span class="nb" id="mwAsM">+</span><span class="w" id="mwAsQ"> </span><span class="mi" id="mwAsU">2</span><span class="p" id="mwAsY">)</span><span class="w" id="mwAsc"> </span><span class="mi" id="mwAsg">1</span><span class="p" id="mwAsk">)</span><span class="w" id="mwAso"> </span><span class="mi" id="mwAss">10</span><span class="p" id="mwAsw">)</span> <span class="w" id="mwAs0"> </span><span class="p" id="mwAs4">(</span><span class="nb" id="mwAs8">+</span><span class="w" id="mwAtA"> </span><span class="mi" id="mwAtE">1</span><span class="w" id="mwAtI"> </span><span class="mi" id="mwAtM">10</span><span class="p" id="mwAtQ">))</span> <span class="w" id="mwAtU"> </span><span class="p" id="mwAtY">(</span><span class="nb" id="mwAtc">=</span><span class="w" id="mwAtg"> </span><span class="p" id="mwAtk">((((</span><span class="nf" id="mwAto">candidate</span><span class="w" id="mwAts"> </span><span class="nb" id="mwAtw">+</span><span class="w" id="mwAt0"> </span><span class="mi" id="mwAt4">3</span><span class="p" id="mwAt8">)</span><span class="w" id="mwAuA"> </span><span class="mi" id="mwAuE">1</span><span class="p" id="mwAuI">)</span><span class="w" id="mwAuM"> </span><span class="mi" id="mwAuQ">10</span><span class="p" id="mwAuU">)</span><span class="w" id="mwAuY"> </span><span class="mi" id="mwAuc">100</span><span class="p" id="mwAug">)</span> <span class="w" id="mwAuk"> </span><span class="p" id="mwAuo">(</span><span class="nb" id="mwAus">+</span><span class="w" id="mwAuw"> </span><span class="mi" id="mwAu0">1</span><span class="w" id="mwAu4"> </span><span class="mi" id="mwAu8">10</span><span class="w" id="mwAvA"> </span><span class="mi" id="mwAvE">100</span><span class="p" id="mwAvI">)))</span> <span class="w" id="mwAvM"> </span><span class="p" id="mwAvQ">(</span><span class="nb" id="mwAvU">=</span><span class="w" id="mwAvY"> </span><span class="p" id="mwAvc">(((((</span><span class="nf" id="mwAvg">candidate</span><span class="w" id="mwAvk"> </span><span class="nb" id="mwAvo">+</span><span class="w" id="mwAvs"> </span><span class="mi" id="mwAvw">4</span><span class="p" id="mwAv0">)</span><span class="w" id="mwAv4"> </span><span class="mi" id="mwAv8">1</span><span class="p" id="mwAwA">)</span><span class="w" id="mwAwE"> </span><span class="mi" id="mwAwI">10</span><span class="p" id="mwAwM">)</span><span class="w" id="mwAwQ"> </span><span class="mi" id="mwAwU">100</span><span class="p" id="mwAwY">)</span><span class="w" id="mwAwc"> </span><span class="mi" id="mwAwg">1000</span><span class="p" id="mwAwk">)</span> <span class="w" id="mwAwo"> </span><span class="p" id="mwAws">(</span><span class="nb" id="mwAww">+</span><span class="w" id="mwAw0"> </span><span class="mi" id="mwAw4">1</span><span class="w" id="mwAw8"> </span><span class="mi" id="mwAxA">10</span><span class="w" id="mwAxE"> </span><span class="mi" id="mwAxI">100</span><span class="w" id="mwAxM"> </span><span class="mi" id="mwAxQ">1000</span><span class="p" id="mwAxU">))))</span>
These unit tests verify whether currying the variadic function + into an n-ary curried function and applying the result to n arguments yields the same result as applying + to these n arguments, for n = 0, 1, 2, 3, and 4.
The following recursive function is accumulator-based and eventually reverses the accumulator before applying the given uncurried function. In each instance of the induction step, the function (lambda (v) ...) is explicitly applied to an argument in the curried application:
<span id="mwAx4"></span><span class="p" id="mwAx8">(</span><span class="k" id="mwAyA">define</span><span class="w" id="mwAyE"> </span><span class="nv" id="mwAyI">curry_a</span> <span class="w" id="mwAyM"> </span><span class="p" id="mwAyQ">(</span><span class="k" id="mwAyU">lambda</span><span class="w" id="mwAyY"> </span><span class="p" id="mwAyc">(</span><span class="nf" id="mwAyg">f</span><span class="w" id="mwAyk"> </span><span class="nv" id="mwAyo">n</span><span class="p" id="mwAys">)</span> <span class="w" id="mwAyw"> </span><span class="p" id="mwAy0">(</span><span class="k" id="mwAy4">if</span><span class="w" id="mwAy8"> </span><span class="p" id="mwAzA">(</span><span class="nb" id="mwAzE"><</span><span class="w" id="mwAzI"> </span><span class="nv" id="mwAzM">n</span><span class="w" id="mwAzQ"> </span><span class="mi" id="mwAzU">0</span><span class="p" id="mwAzY">)</span> <span class="w" id="mwAzc"> </span><span class="p" id="mwAzg">(</span><span class="nb" id="mwAzk">error</span><span class="w" id="mwAzo"> </span><span class="ss" id="mwAzs">'curry_a</span><span class="w" id="mwAzw"> </span><span class="s" id="mwAz0">"negative input: ~s"</span><span class="w" id="mwAz4"> </span><span class="nv" id="mwAz8">n</span><span class="p" id="mwA0A">)</span> <span class="w" id="mwA0E"> </span><span class="p" id="mwA0I">(</span><span class="k" id="mwA0M">letrec</span><span class="w" id="mwA0Q"> </span><span class="p" id="mwA0U">([</span><span class="nv" id="mwA0Y">visit</span><span class="w" id="mwA0c"> </span><span class="p" id="mwA0g">(</span><span class="k" id="mwA0k">lambda</span><span class="w" id="mwA0o"> </span><span class="p" id="mwA0s">(</span><span class="nf" id="mwA0w">i</span><span class="w" id="mwA00"> </span><span class="nv" id="mwA04">a</span><span class="p" id="mwA08">)</span> <span class="w" id="mwA1A"> </span><span class="p" id="mwA1E">(</span><span class="k" id="mwA1I">if</span><span class="w" id="mwA1M"> </span><span class="p" id="mwA1Q">(</span><span class="nb" id="mwA1U">=</span><span class="w" id="mwA1Y"> </span><span class="nv" id="mwA1c">i</span><span class="w" id="mwA1g"> </span><span class="mi" id="mwA1k">0</span><span class="p" id="mwA1o">)</span> <span class="w" id="mwA1s"> </span><span class="p" id="mwA1w">(</span><span class="nb" id="mwA10">apply</span><span class="w" id="mwA14"> </span><span class="nv" id="mwA18">f</span><span class="w" id="mwA2A"> </span><span class="p" id="mwA2E">(</span><span class="nb" id="mwA2I">reverse</span><span class="w" id="mwA2M"> </span><span class="nv" id="mwA2Q">a</span><span class="p" id="mwA2U">))</span> <span class="w" id="mwA2Y"> </span><span class="p" id="mwA2c">(</span><span class="k" id="mwA2g">lambda</span><span class="w" id="mwA2k"> </span><span class="p" id="mwA2o">(</span><span class="nf" id="mwA2s">v</span><span class="p" id="mwA2w">)</span> <span class="w" id="mwA20"> </span><span class="p" id="mwA24">(</span><span class="nf" id="mwA28">visit</span><span class="w" id="mwA3A"> </span><span class="p" id="mwA3E">(</span><span class="nb" id="mwA3I">-</span><span class="w" id="mwA3M"> </span><span class="nv" id="mwA3Q">i</span><span class="w" id="mwA3U"> </span><span class="mi" id="mwA3Y">1</span><span class="p" id="mwA3c">)</span><span class="w" id="mwA3g"> </span><span class="p" id="mwA3k">(</span><span class="nb" id="mwA3o">cons</span><span class="w" id="mwA3s"> </span><span class="nv" id="mwA3w">v</span><span class="w" id="mwA30"> </span><span class="nv" id="mwA34">a</span><span class="p" id="mwA38">)))))])</span> <span class="w" id="mwA4A"> </span><span class="p" id="mwA4E">(</span><span class="nf" id="mwA4I">visit</span><span class="w" id="mwA4M"> </span><span class="nv" id="mwA4Q">n</span><span class="w" id="mwA4U"> </span><span class="o" id="mwA4Y">'</span><span class="p" id="mwA4c">())))))</span>
For example, evaluating
<span id="mwA4s"></span><span class="p" id="mwA4w">(((</span><span class="nf" id="mwA40">curry_a</span><span class="w" id="mwA44"> </span><span class="nb" id="mwA48">+</span><span class="w" id="mwA5A"> </span><span class="mi" id="mwA5E">2</span><span class="p" id="mwA5I">)</span><span class="w" id="mwA5M"> </span><span class="mi" id="mwA5Q">1</span><span class="p" id="mwA5U">)</span><span class="w" id="mwA5Y"> </span><span class="mi" id="mwA5c">10</span><span class="p" id="mwA5g">)</span>
reduces to evaluating
<span id="mwA5w"></span><span class="p" id="mwA50">(((</span><span class="nf" id="mwA54">visit</span><span class="w" id="mwA58"> </span><span class="mi" id="mwA6A">2</span><span class="w" id="mwA6E"> </span><span class="o" id="mwA6I">'</span><span class="p" id="mwA6M">())</span><span class="w" id="mwA6Q"> </span><span class="mi" id="mwA6U">1</span><span class="p" id="mwA6Y">)</span><span class="w" id="mwA6c"> </span><span class="mi" id="mwA6g">10</span><span class="p" id="mwA6k">)</span>
which reduces to evaluating
<span id="mwA60"></span><span class="p" id="mwA64">(((</span><span class="k" id="mwA68">lambda</span><span class="w" id="mwA7A"> </span><span class="p" id="mwA7E">(</span><span class="nf" id="mwA7I">v</span><span class="p" id="mwA7M">)</span><span class="w" id="mwA7Q"> </span><span class="p" id="mwA7U">(</span><span class="nf" id="mwA7Y">visit</span><span class="w" id="mwA7c"> </span><span class="mi" id="mwA7g">1</span><span class="w" id="mwA7k"> </span><span class="p" id="mwA7o">(</span><span class="nb" id="mwA7s">cons</span><span class="w" id="mwA7w"> </span><span class="nv" id="mwA70">v</span><span class="w" id="mwA74"> </span><span class="o" id="mwA78">'</span><span class="p" id="mwA8A">())))</span><span class="w" id="mwA8E"> </span><span class="mi" id="mwA8I">1</span><span class="p" id="mwA8M">)</span><span class="w" id="mwA8Q"> </span><span class="mi" id="mwA8U">10</span><span class="p" id="mwA8Y">)</span>
which beta-reduces to evaluating
<span id="mwA8o"></span><span class="p" id="mwA8s">((</span><span class="nf" id="mwA8w">visit</span><span class="w" id="mwA80"> </span><span class="mi" id="mwA84">1</span><span class="w" id="mwA88"> </span><span class="p" id="mwA9A">(</span><span class="nb" id="mwA9E">cons</span><span class="w" id="mwA9I"> </span><span class="mi" id="mwA9M">1</span><span class="w" id="mwA9Q"> </span><span class="o" id="mwA9U">'</span><span class="p" id="mwA9Y">()))</span><span class="w" id="mwA9c"> </span><span class="mi" id="mwA9g">10</span><span class="p" id="mwA9k">)</span>
which reduces to evaluating
<span id="mwA90"></span><span class="p" id="mwA94">((</span><span class="k" id="mwA98">lambda</span><span class="w" id="mwA-A"> </span><span class="p" id="mwA-E">(</span><span class="nf" id="mwA-I">v</span><span class="p" id="mwA-M">)</span><span class="w" id="mwA-Q"> </span><span class="p" id="mwA-U">(</span><span class="nf" id="mwA-Y">visit</span><span class="w" id="mwA-c"> </span><span class="mi" id="mwA-g">0</span><span class="w" id="mwA-k"> </span><span class="p" id="mwA-o">(</span><span class="nb" id="mwA-s">cons</span><span class="w" id="mwA-w"> </span><span class="nv" id="mwA-0">v</span><span class="w" id="mwA-4"> </span><span class="p" id="mwA-8">(</span><span class="nb" id="mwA_A">cons</span><span class="w" id="mwA_E"> </span><span class="mi" id="mwA_I">1</span><span class="w" id="mwA_M"> </span><span class="o" id="mwA_Q">'</span><span class="p" id="mwA_U">()))))</span><span class="w" id="mwA_Y"> </span><span class="mi" id="mwA_c">10</span><span class="p" id="mwA_g">)</span>
which beta-reduces to evaluating
<span id="mwA_w"></span><span class="p" id="mwA_0">(</span><span class="nf" id="mwA_4">visit</span><span class="w" id="mwA_8"> </span><span class="mi" id="mwBAA">0</span><span class="w" id="mwBAE"> </span><span class="p" id="mwBAI">(</span><span class="nb" id="mwBAM">cons</span><span class="w" id="mwBAQ"> </span><span class="mi" id="mwBAU">10</span><span class="w" id="mwBAY"> </span><span class="p" id="mwBAc">(</span><span class="nb" id="mwBAg">cons</span><span class="w" id="mwBAk"> </span><span class="mi" id="mwBAo">1</span><span class="w" id="mwBAs"> </span><span class="o" id="mwBAw">'</span><span class="p" id="mwBA0">())))</span>
which reduces to evaluating
<span id="mwBBE"></span><span class="p" id="mwBBI">(</span><span class="nb" id="mwBBM">apply</span><span class="w" id="mwBBQ"> </span><span class="nb" id="mwBBU">+</span><span class="w" id="mwBBY"> </span><span class="p" id="mwBBc">(</span><span class="nb" id="mwBBg">reverse</span><span class="w" id="mwBBk"> </span><span class="p" id="mwBBo">(</span><span class="nb" id="mwBBs">cons</span><span class="w" id="mwBBw"> </span><span class="mi" id="mwBB0">10</span><span class="w" id="mwBB4"> </span><span class="p" id="mwBB8">(</span><span class="nb" id="mwBCA">cons</span><span class="w" id="mwBCE"> </span><span class="mi" id="mwBCI">1</span><span class="w" id="mwBCM"> </span><span class="o" id="mwBCQ">'</span><span class="p" id="mwBCU">()))))</span>
which reduces to evaluating
<span id="mwBCk"></span><span class="p" id="mwBCo">(</span><span class="nb" id="mwBCs">apply</span><span class="w" id="mwBCw"> </span><span class="nb" id="mwBC0">+</span><span class="w" id="mwBC4"> </span><span class="p" id="mwBC8">(</span><span class="nb" id="mwBDA">cons</span><span class="w" id="mwBDE"> </span><span class="mi" id="mwBDI">1</span><span class="w" id="mwBDM"> </span><span class="p" id="mwBDQ">(</span><span class="nb" id="mwBDU">cons</span><span class="w" id="mwBDY"> </span><span class="mi" id="mwBDc">10</span><span class="w" id="mwBDg"> </span><span class="o" id="mwBDk">'</span><span class="p" id="mwBDo">())))</span>
which is equivalent to
<span id="mwBD4"></span><span class="p" id="mwBD8">(</span><span class="nb" id="mwBEA">+</span><span class="w" id="mwBEE"> </span><span class="mi" id="mwBEI">1</span><span class="w" id="mwBEM"> </span><span class="mi" id="mwBEQ">10</span><span class="p" id="mwBEU">)</span>
which delta-reduces to the result, 11.
The following recursive function is continuation-based and involves no list reversal. Likewise, in each instance of the induction step, the function (lambda (v) ...) is explicitly applied to an argument in the curried application:
<span id="mwBEw"></span><span class="p" id="mwBE0">(</span><span class="k" id="mwBE4">define</span><span class="w" id="mwBE8"> </span><span class="nv" id="mwBFA">curry_c</span> <span class="w" id="mwBFE"> </span><span class="p" id="mwBFI">(</span><span class="k" id="mwBFM">lambda</span><span class="w" id="mwBFQ"> </span><span class="p" id="mwBFU">(</span><span class="nf" id="mwBFY">f</span><span class="w" id="mwBFc"> </span><span class="nv" id="mwBFg">n</span><span class="p" id="mwBFk">)</span> <span class="w" id="mwBFo"> </span><span class="p" id="mwBFs">(</span><span class="k" id="mwBFw">if</span><span class="w" id="mwBF0"> </span><span class="p" id="mwBF4">(</span><span class="nb" id="mwBF8"><</span><span class="w" id="mwBGA"> </span><span class="nv" id="mwBGE">n</span><span class="w" id="mwBGI"> </span><span class="mi" id="mwBGM">0</span><span class="p" id="mwBGQ">)</span> <span class="w" id="mwBGU"> </span><span class="p" id="mwBGY">(</span><span class="nb" id="mwBGc">error</span><span class="w" id="mwBGg"> </span><span class="ss" id="mwBGk">'curry_c</span><span class="w" id="mwBGo"> </span><span class="s" id="mwBGs">"negative input: ~s"</span><span class="w" id="mwBGw"> </span><span class="nv" id="mwBG0">n</span><span class="p" id="mwBG4">)</span> <span class="w" id="mwBG8"> </span><span class="p" id="mwBHA">(</span><span class="k" id="mwBHE">letrec</span><span class="w" id="mwBHI"> </span><span class="p" id="mwBHM">([</span><span class="nv" id="mwBHQ">visit</span><span class="w" id="mwBHU"> </span><span class="p" id="mwBHY">(</span><span class="k" id="mwBHc">lambda</span><span class="w" id="mwBHg"> </span><span class="p" id="mwBHk">(</span><span class="nf" id="mwBHo">i</span><span class="w" id="mwBHs"> </span><span class="nv" id="mwBHw">c</span><span class="p" id="mwBH0">)</span> <span class="w" id="mwBH4"> </span><span class="p" id="mwBH8">(</span><span class="k" id="mwBIA">if</span><span class="w" id="mwBIE"> </span><span class="p" id="mwBII">(</span><span class="nb" id="mwBIM">=</span><span class="w" id="mwBIQ"> </span><span class="nv" id="mwBIU">i</span><span class="w" id="mwBIY"> </span><span class="mi" id="mwBIc">0</span><span class="p" id="mwBIg">)</span> <span class="w" id="mwBIk"> </span><span class="p" id="mwBIo">(</span><span class="nf" id="mwBIs">c</span><span class="w" id="mwBIw"> </span><span class="o" id="mwBI0">'</span><span class="p" id="mwBI4">())</span> <span class="w" id="mwBI8"> </span><span class="p" id="mwBJA">(</span><span class="k" id="mwBJE">lambda</span><span class="w" id="mwBJI"> </span><span class="p" id="mwBJM">(</span><span class="nf" id="mwBJQ">v</span><span class="p" id="mwBJU">)</span> <span class="w" id="mwBJY"> </span><span class="p" id="mwBJc">(</span><span class="nf" id="mwBJg">visit</span><span class="w" id="mwBJk"> </span><span class="p" id="mwBJo">(</span><span class="nb" id="mwBJs">-</span><span class="w" id="mwBJw"> </span><span class="nv" id="mwBJ0">i</span><span class="w" id="mwBJ4"> </span><span class="mi" id="mwBJ8">1</span><span class="p" id="mwBKA">)</span><span class="w" id="mwBKE"> </span><span class="p" id="mwBKI">(</span><span class="k" id="mwBKM">lambda</span><span class="w" id="mwBKQ"> </span><span class="p" id="mwBKU">(</span><span class="nf" id="mwBKY">vs</span><span class="p" id="mwBKc">)</span> <span class="w" id="mwBKg"> </span><span class="p" id="mwBKk">(</span><span class="nf" id="mwBKo">c</span><span class="w" id="mwBKs"> </span><span class="p" id="mwBKw">(</span><span class="nb" id="mwBK0">cons</span><span class="w" id="mwBK4"> </span><span class="nv" id="mwBK8">v</span><span class="w" id="mwBLA"> </span><span class="nv" id="mwBLE">vs</span><span class="p" id="mwBLI">)))))))])</span> <span class="w" id="mwBLM"> </span><span class="p" id="mwBLQ">(</span><span class="nf" id="mwBLU">visit</span><span class="w" id="mwBLY"> </span><span class="nv" id="mwBLc">n</span><span class="w" id="mwBLg"> </span><span class="p" id="mwBLk">(</span><span class="k" id="mwBLo">lambda</span><span class="w" id="mwBLs"> </span><span class="p" id="mwBLw">(</span><span class="nf" id="mwBL0">vs</span><span class="p" id="mwBL4">)</span> <span class="w" id="mwBL8"> </span><span class="p" id="mwBMA">(</span><span class="nb" id="mwBME">apply</span><span class="w" id="mwBMI"> </span><span class="nv" id="mwBMM">f</span><span class="w" id="mwBMQ"> </span><span class="nv" id="mwBMU">vs</span><span class="p" id="mwBMY">)))))))</span>
So evaluating
<span id="mwBMo"></span><span class="p" id="mwBMs">(((</span><span class="nf" id="mwBMw">curry_c</span><span class="w" id="mwBM0"> </span><span class="nb" id="mwBM4">+</span><span class="w" id="mwBM8"> </span><span class="mi" id="mwBNA">2</span><span class="p" id="mwBNE">)</span><span class="w" id="mwBNI"> </span><span class="mi" id="mwBNM">1</span><span class="p" id="mwBNQ">)</span><span class="w" id="mwBNU"> </span><span class="mi" id="mwBNY">10</span><span class="p" id="mwBNc">)</span>
reduces to evaluating
<span id="mwBNs"></span><span class="p" id="mwBNw">(((</span><span class="nf" id="mwBN0">visit</span><span class="w" id="mwBN4"> </span><span class="mi" id="mwBN8">2</span><span class="w" id="mwBOA"> </span><span class="p" id="mwBOE">(</span><span class="k" id="mwBOI">lambda</span><span class="w" id="mwBOM"> </span><span class="p" id="mwBOQ">(</span><span class="nf" id="mwBOU">vs</span><span class="p" id="mwBOY">)</span><span class="w" id="mwBOc"> </span><span class="p" id="mwBOg">(</span><span class="nb" id="mwBOk">apply</span><span class="w" id="mwBOo"> </span><span class="nb" id="mwBOs">+</span><span class="w" id="mwBOw"> </span><span class="nv" id="mwBO0">vs</span><span class="p" id="mwBO4">)))</span><span class="w" id="mwBO8"> </span><span class="mi" id="mwBPA">1</span><span class="p" id="mwBPE">)</span><span class="w" id="mwBPI"> </span><span class="mi" id="mwBPM">10</span><span class="p" id="mwBPQ">)</span>
which reduces to evaluating
<span id="mwBPg"></span><span class="p" id="mwBPk">(((</span><span class="k" id="mwBPo">lambda</span><span class="w" id="mwBPs"> </span><span class="p" id="mwBPw">(</span><span class="nf" id="mwBP0">v</span><span class="p" id="mwBP4">)</span><span class="w" id="mwBP8"> </span><span class="p" id="mwBQA">(</span><span class="nf" id="mwBQE">visit</span><span class="w" id="mwBQI"> </span><span class="mi" id="mwBQM">1</span><span class="w" id="mwBQQ"> </span><span class="p" id="mwBQU">(</span><span class="k" id="mwBQY">lambda</span><span class="w" id="mwBQc"> </span><span class="p" id="mwBQg">(</span><span class="nf" id="mwBQk">vs</span><span class="p" id="mwBQo">)</span><span class="w" id="mwBQs"> </span><span class="p" id="mwBQw">((</span><span class="k" id="mwBQ0">lambda</span><span class="w" id="mwBQ4"> </span><span class="p" id="mwBQ8">(</span><span class="nf" id="mwBRA">vs</span><span class="p" id="mwBRE">)</span><span class="w" id="mwBRI"> </span><span class="p" id="mwBRM">(</span><span class="nb" id="mwBRQ">apply</span><span class="w" id="mwBRU"> </span><span class="nb" id="mwBRY">+</span><span class="w" id="mwBRc"> </span><span class="nv" id="mwBRg">vs</span><span class="p" id="mwBRk">))</span><span class="w" id="mwBRo"> </span><span class="p" id="mwBRs">(</span><span class="nb" id="mwBRw">cons</span><span class="w" id="mwBR0"> </span><span class="nv" id="mwBR4">v</span><span class="w" id="mwBR8"> </span><span class="nv" id="mwBSA">vs</span><span class="p" id="mwBSE">)))))</span><span class="w" id="mwBSI"> </span><span class="mi" id="mwBSM">1</span><span class="p" id="mwBSQ">)</span><span class="w" id="mwBSU"> </span><span class="mi" id="mwBSY">10</span><span class="p" id="mwBSc">)</span>
which beta-reduces to evaluating
<span id="mwBSs"></span><span class="p" id="mwBSw">((</span><span class="nf" id="mwBS0">visit</span><span class="w" id="mwBS4"> </span><span class="mi" id="mwBS8">1</span><span class="w" id="mwBTA"> </span><span class="p" id="mwBTE">(</span><span class="k" id="mwBTI">lambda</span><span class="w" id="mwBTM"> </span><span class="p" id="mwBTQ">(</span><span class="nf" id="mwBTU">vs</span><span class="p" id="mwBTY">)</span><span class="w" id="mwBTc"> </span><span class="p" id="mwBTg">((</span><span class="k" id="mwBTk">lambda</span><span class="w" id="mwBTo"> </span><span class="p" id="mwBTs">(</span><span class="nf" id="mwBTw">vs</span><span class="p" id="mwBT0">)</span><span class="w" id="mwBT4"> </span><span class="p" id="mwBT8">(</span><span class="nb" id="mwBUA">apply</span><span class="w" id="mwBUE"> </span><span class="nb" id="mwBUI">+</span><span class="w" id="mwBUM"> </span><span class="nv" id="mwBUQ">vs</span><span class="p" id="mwBUU">))</span><span class="w" id="mwBUY"> </span><span class="p" id="mwBUc">(</span><span class="nb" id="mwBUg">cons</span><span class="w" id="mwBUk"> </span><span class="mi" id="mwBUo">1</span><span class="w" id="mwBUs"> </span><span class="nv" id="mwBUw">vs</span><span class="p" id="mwBU0">))))</span><span class="w" id="mwBU4"> </span><span class="mi" id="mwBU8">10</span><span class="p" id="mwBVA">)</span>
which reduces to evaluating
<span id="mwBVQ"></span><span class="p" id="mwBVU">((</span><span class="k" id="mwBVY">lambda</span><span class="w" id="mwBVc"> </span><span class="p" id="mwBVg">(</span><span class="nf" id="mwBVk">v</span><span class="p" id="mwBVo">)</span><span class="w" id="mwBVs"> </span><span class="p" id="mwBVw">(</span><span class="nf" id="mwBV0">visit</span><span class="w" id="mwBV4"> </span><span class="mi" id="mwBV8">0</span><span class="w" id="mwBWA"> </span><span class="p" id="mwBWE">(</span><span class="k" id="mwBWI">lambda</span><span class="w" id="mwBWM"> </span><span class="p" id="mwBWQ">(</span><span class="nf" id="mwBWU">vs</span><span class="p" id="mwBWY">)</span><span class="w" id="mwBWc"> </span><span class="p" id="mwBWg">((</span><span class="k" id="mwBWk">lambda</span><span class="w" id="mwBWo"> </span><span class="p" id="mwBWs">(</span><span class="nf" id="mwBWw">vs</span><span class="p" id="mwBW0">)</span><span class="w" id="mwBW4"> </span><span class="p" id="mwBW8">((</span><span class="k" id="mwBXA">lambda</span><span class="w" id="mwBXE"> </span><span class="p" id="mwBXI">(</span><span class="nf" id="mwBXM">vs</span><span class="p" id="mwBXQ">)</span><span class="w" id="mwBXU"> </span><span class="p" id="mwBXY">(</span><span class="nb" id="mwBXc">apply</span><span class="w" id="mwBXg"> </span><span class="nb" id="mwBXk">+</span><span class="w" id="mwBXo"> </span><span class="nv" id="mwBXs">vs</span><span class="p" id="mwBXw">))</span><span class="w" id="mwBX0"> </span><span class="p" id="mwBX4">(</span><span class="nb" id="mwBX8">cons</span><span class="w" id="mwBYA"> </span><span class="mi" id="mwBYE">1</span><span class="w" id="mwBYI"> </span><span class="nv" id="mwBYM">vs</span><span class="p" id="mwBYQ">)))</span><span class="w" id="mwBYU"> </span><span class="p" id="mwBYY">(</span><span class="nb" id="mwBYc">cons</span><span class="w" id="mwBYg"> </span><span class="nv" id="mwBYk">v</span><span class="w" id="mwBYo"> </span><span class="nv" id="mwBYs">vs</span><span class="p" id="mwBYw">)))))</span><span class="w" id="mwBY0"> </span><span class="mi" id="mwBY4">10</span><span class="p" id="mwBY8">)</span>
which beta-reduces to evaluating
<span id="mwBZM"></span><span class="p" id="mwBZQ">(</span><span class="nf" id="mwBZU">visit</span><span class="w" id="mwBZY"> </span><span class="mi" id="mwBZc">0</span><span class="w" id="mwBZg"> </span><span class="p" id="mwBZk">(</span><span class="k" id="mwBZo">lambda</span><span class="w" id="mwBZs"> </span><span class="p" id="mwBZw">(</span><span class="nf" id="mwBZ0">vs</span><span class="p" id="mwBZ4">)</span><span class="w" id="mwBZ8"> </span><span class="p" id="mwBaA">((</span><span class="k" id="mwBaE">lambda</span><span class="w" id="mwBaI"> </span><span class="p" id="mwBaM">(</span><span class="nf" id="mwBaQ">vs</span><span class="p" id="mwBaU">)</span><span class="w" id="mwBaY"> </span><span class="p" id="mwBac">((</span><span class="k" id="mwBag">lambda</span><span class="w" id="mwBak"> </span><span class="p" id="mwBao">(</span><span class="nf" id="mwBas">vs</span><span class="p" id="mwBaw">)</span><span class="w" id="mwBa0"> </span><span class="p" id="mwBa4">(</span><span class="nb" id="mwBa8">apply</span><span class="w" id="mwBbA"> </span><span class="nb" id="mwBbE">+</span><span class="w" id="mwBbI"> </span><span class="nv" id="mwBbM">vs</span><span class="p" id="mwBbQ">))</span><span class="w" id="mwBbU"> </span><span class="p" id="mwBbY">(</span><span class="nb" id="mwBbc">cons</span><span class="w" id="mwBbg"> </span><span class="mi" id="mwBbk">1</span><span class="w" id="mwBbo"> </span><span class="nv" id="mwBbs">vs</span><span class="p" id="mwBbw">)))</span><span class="w" id="mwBb0"> </span><span class="p" id="mwBb4">(</span><span class="nb" id="mwBb8">cons</span><span class="w" id="mwBcA"> </span><span class="mi" id="mwBcE">10</span><span class="w" id="mwBcI"> </span><span class="nv" id="mwBcM">vs</span><span class="p" id="mwBcQ">))))</span>
which reduces to evaluating
<span id="mwBcg"></span><span class="p" id="mwBck">((</span><span class="k" id="mwBco">lambda</span><span class="w" id="mwBcs"> </span><span class="p" id="mwBcw">(</span><span class="nf" id="mwBc0">vs</span><span class="p" id="mwBc4">)</span><span class="w" id="mwBc8"> </span><span class="p" id="mwBdA">((</span><span class="k" id="mwBdE">lambda</span><span class="w" id="mwBdI"> </span><span class="p" id="mwBdM">(</span><span class="nf" id="mwBdQ">vs</span><span class="p" id="mwBdU">)</span><span class="w" id="mwBdY"> </span><span class="p" id="mwBdc">((</span><span class="k" id="mwBdg">lambda</span><span class="w" id="mwBdk"> </span><span class="p" id="mwBdo">(</span><span class="nf" id="mwBds">vs</span><span class="p" id="mwBdw">)</span><span class="w" id="mwBd0"> </span><span class="p" id="mwBd4">(</span><span class="nb" id="mwBd8">apply</span><span class="w" id="mwBeA"> </span><span class="nb" id="mwBeE">+</span><span class="w" id="mwBeI"> </span><span class="nv" id="mwBeM">vs</span><span class="p" id="mwBeQ">))</span><span class="w" id="mwBeU"> </span><span class="p" id="mwBeY">(</span><span class="nb" id="mwBec">cons</span><span class="w" id="mwBeg"> </span><span class="mi" id="mwBek">1</span><span class="w" id="mwBeo"> </span><span class="nv" id="mwBes">vs</span><span class="p" id="mwBew">)))</span><span class="w" id="mwBe0"> </span><span class="p" id="mwBe4">(</span><span class="nb" id="mwBe8">cons</span><span class="w" id="mwBfA"> </span><span class="mi" id="mwBfE">10</span><span class="w" id="mwBfI"> </span><span class="nv" id="mwBfM">vs</span><span class="p" id="mwBfQ">)))</span><span class="w" id="mwBfU"> </span><span class="o" id="mwBfY">'</span><span class="p" id="mwBfc">())</span>
which beta-reduces to evaluating
<span id="mwBfs"></span><span class="p" id="mwBfw">((</span><span class="k" id="mwBf0">lambda</span><span class="w" id="mwBf4"> </span><span class="p" id="mwBf8">(</span><span class="nf" id="mwBgA">vs</span><span class="p" id="mwBgE">)</span><span class="w" id="mwBgI"> </span><span class="p" id="mwBgM">((</span><span class="k" id="mwBgQ">lambda</span><span class="w" id="mwBgU"> </span><span class="p" id="mwBgY">(</span><span class="nf" id="mwBgc">vs</span><span class="p" id="mwBgg">)</span><span class="w" id="mwBgk"> </span><span class="p" id="mwBgo">(</span><span class="nb" id="mwBgs">apply</span><span class="w" id="mwBgw"> </span><span class="nb" id="mwBg0">+</span><span class="w" id="mwBg4"> </span><span class="nv" id="mwBg8">vs</span><span class="p" id="mwBhA">))</span><span class="w" id="mwBhE"> </span><span class="p" id="mwBhI">(</span><span class="nb" id="mwBhM">cons</span><span class="w" id="mwBhQ"> </span><span class="mi" id="mwBhU">1</span><span class="w" id="mwBhY"> </span><span class="nv" id="mwBhc">vs</span><span class="p" id="mwBhg">)))</span><span class="w" id="mwBhk"> </span><span class="p" id="mwBho">(</span><span class="nb" id="mwBhs">cons</span><span class="w" id="mwBhw"> </span><span class="mi" id="mwBh0">10</span><span class="w" id="mwBh4"> </span><span class="o" id="mwBh8">'</span><span class="p" id="mwBiA">()))</span>
which beta-reduces to evaluating
<span id="mwBiQ"></span><span class="p" id="mwBiU">((</span><span class="k" id="mwBiY">lambda</span><span class="w" id="mwBic"> </span><span class="p" id="mwBig">(</span><span class="nf" id="mwBik">vs</span><span class="p" id="mwBio">)</span><span class="w" id="mwBis"> </span><span class="p" id="mwBiw">(</span><span class="nb" id="mwBi0">apply</span><span class="w" id="mwBi4"> </span><span class="nb" id="mwBi8">+</span><span class="w" id="mwBjA"> </span><span class="nv" id="mwBjE">vs</span><span class="p" id="mwBjI">))</span><span class="w" id="mwBjM"> </span><span class="p" id="mwBjQ">(</span><span class="nb" id="mwBjU">cons</span><span class="w" id="mwBjY"> </span><span class="mi" id="mwBjc">1</span><span class="w" id="mwBjg"> </span><span class="p" id="mwBjk">(</span><span class="nb" id="mwBjo">cons</span><span class="w" id="mwBjs"> </span><span class="mi" id="mwBjw">10</span><span class="w" id="mwBj0"> </span><span class="o" id="mwBj4">'</span><span class="p" id="mwBj8">())))</span>
which beta-reduces to evaluating
<span id="mwBkM"></span><span class="p" id="mwBkQ">(</span><span class="nb" id="mwBkU">apply</span><span class="w" id="mwBkY"> </span><span class="nb" id="mwBkc">+</span><span class="w" id="mwBkg"> </span><span class="p" id="mwBkk">(</span><span class="nb" id="mwBko">cons</span><span class="w" id="mwBks"> </span><span class="mi" id="mwBkw">1</span><span class="w" id="mwBk0"> </span><span class="p" id="mwBk4">(</span><span class="nb" id="mwBk8">cons</span><span class="w" id="mwBlA"> </span><span class="mi" id="mwBlE">10</span><span class="w" id="mwBlI"> </span><span class="o" id="mwBlM">'</span><span class="p" id="mwBlQ">())))</span>
which is equivalent to
<span id="mwBlg"></span><span class="p" id="mwBlk">(</span><span class="nb" id="mwBlo">+</span><span class="w" id="mwBls"> </span><span class="mi" id="mwBlw">1</span><span class="w" id="mwBl0"> </span><span class="mi" id="mwBl4">10</span><span class="p" id="mwBl8">)</span>
which delta-reduces to the result, 11.
The following recursive function, curry_d, is the direct-style counterpart of curry_c and features the (shift k k) idiom, using Andrzej Filinski's implementation of shift and reset in terms of a global mutable cell and of call/cc. In each instance of the induction step, the continuation abstraction is implicitly applied to an argument in the curried application:
<span id="mwBm0"></span><span class="p" id="mwBm4">(</span><span class="k" id="mwBm8">define</span><span class="w" id="mwBnA"> </span><span class="nv" id="mwBnE">curry_d</span> <span class="w" id="mwBnI"> </span><span class="p" id="mwBnM">(</span><span class="k" id="mwBnQ">lambda</span><span class="w" id="mwBnU"> </span><span class="p" id="mwBnY">(</span><span class="nf" id="mwBnc">f</span><span class="w" id="mwBng"> </span><span class="nv" id="mwBnk">n</span><span class="p" id="mwBno">)</span> <span class="w" id="mwBns"> </span><span class="p" id="mwBnw">(</span><span class="k" id="mwBn0">if</span><span class="w" id="mwBn4"> </span><span class="p" id="mwBn8">(</span><span class="nb" id="mwBoA"><</span><span class="w" id="mwBoE"> </span><span class="nv" id="mwBoI">n</span><span class="w" id="mwBoM"> </span><span class="mi" id="mwBoQ">0</span><span class="p" id="mwBoU">)</span> <span class="w" id="mwBoY"> </span><span class="p" id="mwBoc">(</span><span class="nb" id="mwBog">error</span><span class="w" id="mwBok"> </span><span class="ss" id="mwBoo">'curry_d</span><span class="w" id="mwBos"> </span><span class="s" id="mwBow">"negative input: ~s"</span><span class="w" id="mwBo0"> </span><span class="nv" id="mwBo4">n</span><span class="p" id="mwBo8">)</span> <span class="w" id="mwBpA"> </span><span class="p" id="mwBpE">(</span><span class="k" id="mwBpI">letrec</span><span class="w" id="mwBpM"> </span><span class="p" id="mwBpQ">([</span><span class="nv" id="mwBpU">visit</span><span class="w" id="mwBpY"> </span><span class="p" id="mwBpc">(</span><span class="k" id="mwBpg">lambda</span><span class="w" id="mwBpk"> </span><span class="p" id="mwBpo">(</span><span class="nf" id="mwBps">i</span><span class="p" id="mwBpw">)</span> <span class="w" id="mwBp0"> </span><span class="p" id="mwBp4">(</span><span class="k" id="mwBp8">if</span><span class="w" id="mwBqA"> </span><span class="p" id="mwBqE">(</span><span class="nb" id="mwBqI">=</span><span class="w" id="mwBqM"> </span><span class="nv" id="mwBqQ">i</span><span class="w" id="mwBqU"> </span><span class="mi" id="mwBqY">0</span><span class="p" id="mwBqc">)</span> <span class="w" id="mwBqg"> </span><span class="o" id="mwBqk">'</span><span class="p" id="mwBqo">()</span> <span class="w" id="mwBqs"> </span><span class="p" id="mwBqw">(</span><span class="nb" id="mwBq0">cons</span><span class="w" id="mwBq4"> </span><span class="p" id="mwBq8">(</span><span class="nf" id="mwBrA">shift</span><span class="w" id="mwBrE"> </span><span class="nv" id="mwBrI">k</span><span class="w" id="mwBrM"> </span><span class="nv" id="mwBrQ">k</span><span class="p" id="mwBrU">)</span> <span class="w" id="mwBrY"> </span><span class="p" id="mwBrc">(</span><span class="nf" id="mwBrg">visit</span><span class="w" id="mwBrk"> </span><span class="p" id="mwBro">(</span><span class="nb" id="mwBrs">-</span><span class="w" id="mwBrw"> </span><span class="nv" id="mwBr0">i</span><span class="w" id="mwBr4"> </span><span class="mi" id="mwBr8">1</span><span class="p" id="mwBsA">)))))])</span> <span class="w" id="mwBsE"> </span><span class="p" id="mwBsI">(</span><span class="nf" id="mwBsM">reset</span><span class="w" id="mwBsQ"> </span><span class="p" id="mwBsU">(</span><span class="nb" id="mwBsY">apply</span><span class="w" id="mwBsc"> </span><span class="nv" id="mwBsg">f</span><span class="w" id="mwBsk"> </span><span class="p" id="mwBso">(</span><span class="nf" id="mwBss">visit</span><span class="w" id="mwBsw"> </span><span class="nv" id="mwBs0">n</span><span class="p" id="mwBs4">)))))))</span>
The heart of the matter is the observational equivalence between (reset (... (shift k k) ...)) and (lambda (x) (reset (... x ...))) where x is fresh and the ellipses represent a pure context, i.e., one without control effects.
So evaluating
<span id="mwBtY"></span><span class="p" id="mwBtc">(((</span><span class="nf" id="mwBtg">curry_d</span><span class="w" id="mwBtk"> </span><span class="nb" id="mwBto">+</span><span class="w" id="mwBts"> </span><span class="mi" id="mwBtw">2</span><span class="p" id="mwBt0">)</span><span class="w" id="mwBt4"> </span><span class="mi" id="mwBt8">1</span><span class="p" id="mwBuA">)</span><span class="w" id="mwBuE"> </span><span class="mi" id="mwBuI">10</span><span class="p" id="mwBuM">)</span>
reduces to evaluating
<span id="mwBuc"></span><span class="p" id="mwBug">(((</span><span class="nf" id="mwBuk">reset</span><span class="w" id="mwBuo"> </span><span class="p" id="mwBus">(</span><span class="nb" id="mwBuw">apply</span><span class="w" id="mwBu0"> </span><span class="nb" id="mwBu4">+</span><span class="w" id="mwBu8"> </span><span class="p" id="mwBvA">(</span><span class="nf" id="mwBvE">visit</span><span class="w" id="mwBvI"> </span><span class="mi" id="mwBvM">2</span><span class="p" id="mwBvQ">)))</span><span class="w" id="mwBvU"> </span><span class="mi" id="mwBvY">1</span><span class="p" id="mwBvc">)</span><span class="w" id="mwBvg"> </span><span class="mi" id="mwBvk">10</span><span class="p" id="mwBvo">)</span>
which reduces to evaluating
<span id="mwBv4"></span><span class="p" id="mwBv8">(((</span><span class="nf" id="mwBwA">reset</span><span class="w" id="mwBwE"> </span><span class="p" id="mwBwI">(</span><span class="nb" id="mwBwM">apply</span><span class="w" id="mwBwQ"> </span><span class="nb" id="mwBwU">+</span><span class="w" id="mwBwY"> </span><span class="p" id="mwBwc">(</span><span class="nb" id="mwBwg">cons</span><span class="w" id="mwBwk"> </span><span class="p" id="mwBwo">(</span><span class="nf" id="mwBws">shift</span><span class="w" id="mwBww"> </span><span class="nv" id="mwBw0">k</span><span class="w" id="mwBw4"> </span><span class="nv" id="mwBw8">k</span><span class="p" id="mwBxA">)</span><span class="w" id="mwBxE"> </span><span class="p" id="mwBxI">(</span><span class="nf" id="mwBxM">visit</span><span class="w" id="mwBxQ"> </span><span class="mi" id="mwBxU">1</span><span class="p" id="mwBxY">))))</span><span class="w" id="mwBxc"> </span><span class="mi" id="mwBxg">1</span><span class="p" id="mwBxk">)</span><span class="w" id="mwBxo"> </span><span class="mi" id="mwBxs">10</span><span class="p" id="mwBxw">)</span>
which is observationally equivalent to
<span id="mwByA"></span><span class="p" id="mwByE">(((</span><span class="k" id="mwByI">lambda</span><span class="w" id="mwByM"> </span><span class="p" id="mwByQ">(</span><span class="nf" id="mwByU">x</span><span class="p" id="mwByY">)</span><span class="w" id="mwByc"> </span><span class="p" id="mwByg">(</span><span class="nf" id="mwByk">reset</span><span class="w" id="mwByo"> </span><span class="p" id="mwBys">(</span><span class="nb" id="mwByw">apply</span><span class="w" id="mwBy0"> </span><span class="nb" id="mwBy4">+</span><span class="w" id="mwBy8"> </span><span class="p" id="mwBzA">(</span><span class="nb" id="mwBzE">cons</span><span class="w" id="mwBzI"> </span><span class="nv" id="mwBzM">x</span><span class="w" id="mwBzQ"> </span><span class="p" id="mwBzU">(</span><span class="nf" id="mwBzY">visit</span><span class="w" id="mwBzc"> </span><span class="mi" id="mwBzg">1</span><span class="p" id="mwBzk">)))))</span><span class="w" id="mwBzo"> </span><span class="mi" id="mwBzs">1</span><span class="p" id="mwBzw">)</span><span class="w" id="mwBz0"> </span><span class="mi" id="mwBz4">10</span><span class="p" id="mwBz8">)</span>
which beta-reduces to evaluating
<span id="mwB0M"></span><span class="p" id="mwB0Q">((</span><span class="nf" id="mwB0U">reset</span><span class="w" id="mwB0Y"> </span><span class="p" id="mwB0c">(</span><span class="nb" id="mwB0g">apply</span><span class="w" id="mwB0k"> </span><span class="nb" id="mwB0o">+</span><span class="w" id="mwB0s"> </span><span class="p" id="mwB0w">(</span><span class="nb" id="mwB00">cons</span><span class="w" id="mwB04"> </span><span class="mi" id="mwB08">1</span><span class="w" id="mwB1A"> </span><span class="p" id="mwB1E">(</span><span class="nf" id="mwB1I">visit</span><span class="w" id="mwB1M"> </span><span class="mi" id="mwB1Q">1</span><span class="p" id="mwB1U">))))</span><span class="w" id="mwB1Y"> </span><span class="mi" id="mwB1c">10</span><span class="p" id="mwB1g">)</span>
which reduces to evaluating
<span id="mwB1w"></span><span class="p" id="mwB10">((</span><span class="nf" id="mwB14">reset</span><span class="w" id="mwB18"> </span><span class="p" id="mwB2A">(</span><span class="nb" id="mwB2E">apply</span><span class="w" id="mwB2I"> </span><span class="nb" id="mwB2M">+</span><span class="w" id="mwB2Q"> </span><span class="p" id="mwB2U">(</span><span class="nb" id="mwB2Y">cons</span><span class="w" id="mwB2c"> </span><span class="mi" id="mwB2g">1</span><span class="w" id="mwB2k"> </span><span class="p" id="mwB2o">(</span><span class="nb" id="mwB2s">cons</span><span class="w" id="mwB2w"> </span><span class="p" id="mwB20">(</span><span class="nf" id="mwB24">shift</span><span class="w" id="mwB28"> </span><span class="nv" id="mwB3A">k</span><span class="w" id="mwB3E"> </span><span class="nv" id="mwB3I">k</span><span class="p" id="mwB3M">)</span><span class="w" id="mwB3Q"> </span><span class="p" id="mwB3U">(</span><span class="nf" id="mwB3Y">visit</span><span class="w" id="mwB3c"> </span><span class="mi" id="mwB3g">0</span><span class="p" id="mwB3k">)))))</span><span class="w" id="mwB3o"> </span><span class="mi" id="mwB3s">10</span><span class="p" id="mwB3w">)</span>
which is observationally equivalent to
<span id="mwB4A"></span><span class="p" id="mwB4E">((</span><span class="k" id="mwB4I">lambda</span><span class="w" id="mwB4M"> </span><span class="p" id="mwB4Q">(</span><span class="nf" id="mwB4U">x</span><span class="p" id="mwB4Y">)</span><span class="w" id="mwB4c"> </span><span class="p" id="mwB4g">(</span><span class="nf" id="mwB4k">reset</span><span class="w" id="mwB4o"> </span><span class="p" id="mwB4s">(</span><span class="nb" id="mwB4w">apply</span><span class="w" id="mwB40"> </span><span class="nb" id="mwB44">+</span><span class="w" id="mwB48"> </span><span class="p" id="mwB5A">(</span><span class="nb" id="mwB5E">cons</span><span class="w" id="mwB5I"> </span><span class="mi" id="mwB5M">1</span><span class="w" id="mwB5Q"> </span><span class="p" id="mwB5U">(</span><span class="nb" id="mwB5Y">cons</span><span class="w" id="mwB5c"> </span><span class="nv" id="mwB5g">x</span><span class="w" id="mwB5k"> </span><span class="p" id="mwB5o">(</span><span class="nf" id="mwB5s">visit</span><span class="w" id="mwB5w"> </span><span class="mi" id="mwB50">0</span><span class="p" id="mwB54">))))))</span><span class="w" id="mwB58"> </span><span class="mi" id="mwB6A">10</span><span class="p" id="mwB6E">)</span>
which beta-reduces to evaluating
<span id="mwB6U"></span><span class="p" id="mwB6Y">(</span><span class="nf" id="mwB6c">reset</span><span class="w" id="mwB6g"> </span><span class="p" id="mwB6k">(</span><span class="nb" id="mwB6o">apply</span><span class="w" id="mwB6s"> </span><span class="nb" id="mwB6w">+</span><span class="w" id="mwB60"> </span><span class="p" id="mwB64">(</span><span class="nb" id="mwB68">cons</span><span class="w" id="mwB7A"> </span><span class="mi" id="mwB7E">1</span><span class="w" id="mwB7I"> </span><span class="p" id="mwB7M">(</span><span class="nb" id="mwB7Q">cons</span><span class="w" id="mwB7U"> </span><span class="mi" id="mwB7Y">10</span><span class="w" id="mwB7c"> </span><span class="p" id="mwB7g">(</span><span class="nf" id="mwB7k">visit</span><span class="w" id="mwB7o"> </span><span class="mi" id="mwB7s">0</span><span class="p" id="mwB7w">)))))</span>
which reduces to evaluating
<span id="mwB8A"></span><span class="p" id="mwB8E">(</span><span class="nf" id="mwB8I">reset</span><span class="w" id="mwB8M"> </span><span class="p" id="mwB8Q">(</span><span class="nb" id="mwB8U">apply</span><span class="w" id="mwB8Y"> </span><span class="nb" id="mwB8c">+</span><span class="w" id="mwB8g"> </span><span class="p" id="mwB8k">(</span><span class="nb" id="mwB8o">cons</span><span class="w" id="mwB8s"> </span><span class="mi" id="mwB8w">1</span><span class="w" id="mwB80"> </span><span class="p" id="mwB84">(</span><span class="nb" id="mwB88">cons</span><span class="w" id="mwB9A"> </span><span class="mi" id="mwB9E">10</span><span class="w" id="mwB9I"> </span><span class="o" id="mwB9M">'</span><span class="p" id="mwB9Q">()))))</span>
which is equivalent to
<span id="mwB9g"></span><span class="p" id="mwB9k">(</span><span class="nf" id="mwB9o">reset</span><span class="w" id="mwB9s"> </span><span class="p" id="mwB9w">(</span><span class="nb" id="mwB90">+</span><span class="w" id="mwB94"> </span><span class="mi" id="mwB98">1</span><span class="w" id="mwB-A"> </span><span class="mi" id="mwB-E">10</span><span class="p" id="mwB-I">))</span>
which delta-reduces to evaluating
<span id="mwB-Y"></span><span class="p" id="mwB-c">(</span><span class="nf" id="mwB-g">reset</span><span class="w" id="mwB-k"> </span><span class="mi" id="mwB-o">11</span><span class="p" id="mwB-s">)</span>
which yields the result, 11.
The definition of curry_d also illustrates static delimited continuations. This static extent needs to be explicitly encoded if one wants to use control and prompt:
<span id="mwB_g"></span><span class="p" id="mwB_k">(</span><span class="k" id="mwB_o">define</span><span class="w" id="mwB_s"> </span><span class="nv" id="mwB_w">curry_cp</span> <span class="w" id="mwB_0"> </span><span class="p" id="mwB_4">(</span><span class="k" id="mwB_8">lambda</span><span class="w" id="mwCAA"> </span><span class="p" id="mwCAE">(</span><span class="nf" id="mwCAI">f</span><span class="w" id="mwCAM"> </span><span class="nv" id="mwCAQ">n</span><span class="p" id="mwCAU">)</span> <span class="w" id="mwCAY"> </span><span class="p" id="mwCAc">(</span><span class="k" id="mwCAg">if</span><span class="w" id="mwCAk"> </span><span class="p" id="mwCAo">(</span><span class="nb" id="mwCAs"><</span><span class="w" id="mwCAw"> </span><span class="nv" id="mwCA0">n</span><span class="w" id="mwCA4"> </span><span class="mi" id="mwCA8">0</span><span class="p" id="mwCBA">)</span> <span class="w" id="mwCBE"> </span><span class="p" id="mwCBI">(</span><span class="nb" id="mwCBM">error</span><span class="w" id="mwCBQ"> </span><span class="ss" id="mwCBU">'curry_cp</span><span class="w" id="mwCBY"> </span><span class="s" id="mwCBc">"negative input: ~s"</span><span class="w" id="mwCBg"> </span><span class="nv" id="mwCBk">n</span><span class="p" id="mwCBo">)</span> <span class="w" id="mwCBs"> </span><span class="p" id="mwCBw">(</span><span class="k" id="mwCB0">letrec</span><span class="w" id="mwCB4"> </span><span class="p" id="mwCB8">([</span><span class="nv" id="mwCCA">visit</span><span class="w" id="mwCCE"> </span><span class="p" id="mwCCI">(</span><span class="k" id="mwCCM">lambda</span><span class="w" id="mwCCQ"> </span><span class="p" id="mwCCU">(</span><span class="nf" id="mwCCY">i</span><span class="p" id="mwCCc">)</span> <span class="w" id="mwCCg"> </span><span class="p" id="mwCCk">(</span><span class="k" id="mwCCo">if</span><span class="w" id="mwCCs"> </span><span class="p" id="mwCCw">(</span><span class="nb" id="mwCC0">=</span><span class="w" id="mwCC4"> </span><span class="nv" id="mwCC8">i</span><span class="w" id="mwCDA"> </span><span class="mi" id="mwCDE">0</span><span class="p" id="mwCDI">)</span> <span class="w" id="mwCDM"> </span><span class="o" id="mwCDQ">'</span><span class="p" id="mwCDU">()</span> <span class="w" id="mwCDY"> </span><span class="p" id="mwCDc">(</span><span class="nb" id="mwCDg">cons</span><span class="w" id="mwCDk"> </span><span class="p" id="mwCDo">(</span><span class="nf" id="mwCDs">control</span><span class="w" id="mwCDw"> </span><span class="nv" id="mwCD0">k</span><span class="w" id="mwCD4"> </span><span class="p" id="mwCD8">(</span><span class="k" id="mwCEA">lambda</span><span class="w" id="mwCEE"> </span><span class="p" id="mwCEI">(</span><span class="nf" id="mwCEM">x</span><span class="p" id="mwCEQ">)</span><span class="w" id="mwCEU"> </span><span class="p" id="mwCEY">(</span><span class="nf" id="mwCEc">prompt</span><span class="w" id="mwCEg"> </span><span class="p" id="mwCEk">(</span><span class="nf" id="mwCEo">k</span><span class="w" id="mwCEs"> </span><span class="nv" id="mwCEw">x</span><span class="p" id="mwCE0">))))</span> <span class="w" id="mwCE4"> </span><span class="p" id="mwCE8">(</span><span class="nf" id="mwCFA">visit</span><span class="w" id="mwCFE"> </span><span class="p" id="mwCFI">(</span><span class="nb" id="mwCFM">-</span><span class="w" id="mwCFQ"> </span><span class="nv" id="mwCFU">i</span><span class="w" id="mwCFY"> </span><span class="mi" id="mwCFc">1</span><span class="p" id="mwCFg">)))))])</span> <span class="w" id="mwCFk"> </span><span class="p" id="mwCFo">(</span><span class="nf" id="mwCFs">prompt</span><span class="w" id="mwCFw"> </span><span class="p" id="mwCF0">(</span><span class="nb" id="mwCF4">apply</span><span class="w" id="mwCF8"> </span><span class="nv" id="mwCGA">f</span><span class="w" id="mwCGE"> </span><span class="p" id="mwCGI">(</span><span class="nf" id="mwCGM">visit</span><span class="w" id="mwCGQ"> </span><span class="nv" id="mwCGU">n</span><span class="p" id="mwCGY">)))))))</span>