[gambit-list] Continuations bug in v4.6.2?

Patrick Li patrickli.2001 at gmail.com
Mon Dec 9 23:01:10 EST 2013


I am developing the semantics for a formulation of coroutines that I've
been working on. In vague-ish english words, make-jp returns a "callable
thing", which I am calling a "jump point". Every time that a "jump point"
is called, execution jumps to the last place where the jump-point was
invoked.

If Bigloo, Chicken, and Gambit all behave the same way then I think you are
probably right and that this is proper behavior.

However, this leaves me feeling deeply disturbed. I feel that

(f (g x))

should *always* be absolutely equivalent to:

(let [(temp (g x))]
   (f temp))

My example indicates that this is not necessarily the case. Are there other
situations where this is not true? I suspect that I don't quite understand
the interaction between tail-calls and continuations properly.

  -Patrick


On Mon, Dec 9, 2013 at 7:50 PM, Marc Feeley <feeley at iro.umontreal.ca> wrote:

> I tried your code with Bigloo, Chicken and Gambit.  All three systems give
> the same result, so I doubt there is a bug.  Perhaps you can explain what
> you are trying to achieve.
>
> Marc
>
> On Dec 9, 2013, at 10:10 PM, Patrick Li <patrickli.2001 at gmail.com> wrote:
>
> > 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
> >
> > _______________________________________________
> > Gambit-list mailing list
> > Gambit-list at iro.umontreal.ca
> > https://webmail.iro.umontreal.ca/mailman/listinfo/gambit-list
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mailman.iro.umontreal.ca/pipermail/gambit-list/attachments/20131209/7c3e9992/attachment.htm>


More information about the Gambit-list mailing list