Hello!

I've been writing some tricky code involving continuations, and ran into the

following surprising behavior from Gambit v.4.6.2 running on OSX. 

I have two versions of "make-jp", that I believe should be

equivalent. 

   Version 1:

      (define (make-jp block)

        (let [(return-point '())]    

          (call/cc (lambda (ret)

            (define (jp x)

              (call/cc (lambda (ret)

                 (let [(r return-point)]

                   (set! return-point ret)

                   (r x)))))

            (set! return-point ret)

            (let [(result (block jp))]

              (return-point result))))))

   Version 2: 

      (define (make-jp block)

        (let [(return-point '())]    

          (call/cc (lambda (ret)

            (define (jp x)

              (call/cc (lambda (ret)

                 (let [(r return-point)]

                   (set! return-point ret)

                   (r x)))))

            (set! return-point ret)

            (return-point (block jp))))))

The only difference is the final line:

   Version 1:

      (let [(result (block jp))]

        (return-point result))

   Version 2:

      (return-point (block jp))

However, I get different behavior when I test with the following code:

   Testing Code:

      (let* [(j '())]

        (make-jp (lambda (y)

           (set! j y)

           (y 0)

           10))

        (println "GOT: " (j "X")))

   Version 1 prints:

      GOT: 10

   Version 2 prints:

      GOT: X

Out of the two behaviours, I expect the answer given by Version 1. 

Can anyone verify whether this is a bug, and whether the latest

version also shows this behavior?  This fell out of a piece of code

I'm using to simulate coroutines for an interpreter that I am

programming. Here I've tried to isolate the problem down to as few

lines as possible.

Once I get my environment fixed, I will try it on the latest version

of Gambit as well and see if the problem is still there.

  -Patrick