(message (Hello 'Paul)
(you :wrote :on '(09 Dec 2006 02:55:49 -0800))
(
PR> "Alex Mizrahi" <[EMAIL PROTECTED]> writes:
??>> we can implement Scheme's call-with-current-continuation first :)
??>> it's relatively easy -- just a code walker that coverts everyting into
??>> CPS.
PR> It's not enough to convert to CPS, you have to be able to actually
PR> save the continuation when you switch to another one, so you can go
PR> back to the first one later. Maybe I'm missing something but I just
PR> don't see how to do that in the Lisp execution model.
once you convert code to CPS, you can save continuation -- that would be a
simple closure.
let's check how it works using CPS from ARNESI library.
(setq *cc* (with-call/cc (print 1) (let/cc cc cc) (print 3)))
that prints 1 and returns continuation.
when we call that contination:
(funcall *cc* nil)
it prints 3.
we can do a generator now:
(defun gen1 ()
(let (state)
(setf state
(lambda (ignored)
(with-call/cc
(loop for i upfrom 1
do (let/cc cc
(setf state cc)
i)))))
(lambda () (funcall state nil))))
(setq *gen* (gen1))
(funcall *gen*) => 1
(funcall *gen*) => 2
(funcall *gen*) => 3
then we can make a defgenerator macro so it will look like:
(defgenerator gen1 ()
(loop for i upfrom 1 do (yield i))
certainly yield is (let/cc cc (setf state cc) value)
PR> I guess you could write an interpreter in Lisp that simulates it all,
PR> but it might as well be a Python interpreter ;-).
no, we can just transform code, and it can be then compiled or whatever.
there is only additional overhead (lambda and friends) for each call/cc. all
"continuous" forms can be efficiently compiled.
)
(With-best-regards '(Alex Mizrahi) :aka 'killer_storm)
"People who lust for the Feel of keys on their fingertips (c) Inity")
--
http://mail.python.org/mailman/listinfo/python-list
