Ah ha! Thank you Marc for that explanation. It was something so simple all along! I spent a considerable number of hours staring at these few lines today. Sorry for leaping to conclusions regarding the integrity of your code! -Patrick
On Mon, Dec 9, 2013 at 8:29 PM, Marc Feeley feeley@iro.umontreal.ca wrote:
On Dec 9, 2013, at 11:01 PM, Patrick Li patrickli.2001@gmail.com wrote:
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.
When evaluation is left-to-right (which is not required by the standard, but is common) the expression (f (g x)) is evaluated as though it was
(let ((t1 f)) ;; get value of f (let ((t2 g)) ;; get value of g (let ((t3 x)) ;; get value of x (let ((t4 (t2 t3))) ;; call (g x) (t1 t4))))) ;; call (f (g x))
The expression (let ((temp (g x))) (f temp)) forces a different order, namely
(let ((t1 g)) ;; get value of g (let ((t2 x)) ;; get value of x (let ((t3 (t1 t2))) ;; call (g x) (let ((t4 f)) ;; get value of f (t4 t3))))) ;; call (f temp)
In your code, this makes a difference because f (which is "return-point" in your code) is being mutated during the evaluation of the call to g.
In your "version 1", the function originally bound to return-point will be called (i.e. the continuation of the function make-jp). In your "version 2", the function bound to return-point by the call to (block jp) will be called (i.e. the continuation of the call (y 0)).
Marc