## Resume using continuations

I am looking at a way to implement Resume in a CPS-based intermediate language. Resume allows to try again a calculation with a different value.

If I mark the resume value with ^retry I want to do:

1 + ^retry 8  (* 9 *)
retry 5       (* 6 *)

In CPS, 1 + 8 may look like:

lambda (k) (k (+ 1 8))

Then I will extract the continuation around "8" to save it in a "retry" variable:

lambda (k) ((lambda (n) (k (+ 1 n))) 8)
lambda (k) ((lambda (k') (k' 8)) (lambda (n) (k (+ 1 n))))
(* save continuation *)
lambda (k) ((lambda (k') (do ((set! retry k') (k' 8)))) (lambda (n) (k (+ 1 n))))

I could do the same transformation for an arbitrary nested variable. What I do not like is that I use a "global" variable retry which I set!, but the alternative is to pass it around as a function parameter-- not very convenient.

Is my reasoning correct? Is there a better way?

## Comment viewing options

### Infinite loop

One concern is that k is captured in the retry continuation, and will result in an infinite loop if k contains retry.

### Delimited continuations

If you replace (begin (set! retry k') (k' 8)) by (cons k' (k' 8)) then you can access both the resumable calculation and the result from the first try from outside the calculation, without using set!.

### Yes but in CPS I am not sure

Yes but in CPS I am not sure the lambda will ever return.