Hey no-name "dot" you are the only one who says its origin is in
one of the old lambda papers. Give me a reference or someone
give me a reference. I dont have access to any ACM journals or
other conferences. So
Matthias, thanks for the reference, but I dont have access to an
engineering library. I would appreciate, if you have access to paper/
scanner or electronic copy to help many of us out, you are
not just helping me but many will thank you.
I said "I think." Matthias corrected me. They're all on
readscheme.org
( http://library.readscheme.org/page1.html ) though, and well worth
reading.
I note that I'm being mocked for not using my real name by someone not
using his/her real name. Thank you, no-name gnuist006, you make me
laugh.
Matthias, thanks for the reference, but I dont have access to an
engineering library. I would appreciate, if you have access to paper/
scanner or electronic copy to help many of us out, you are
not just helping me but many will thank you.
(1) its origin
(2) its syntax and semantics in emacs lisp, common lisp, scheme
(6) any good readable references that explain it lucidly ?
Again I am depressed to encounter a fundamentally new concept that I
was all along unheard of. Its not even in paul graham's book where i
learnt part of Lisp. Its in Marc Feeley's video.
Can anyone explain:
(1) its origin
(2) its syntax and semantics in emacs lisp, common lisp, scheme
(3) Is it present in python and java ?
(4) Its implementation in assembly. for example in the manner that
pointer fundamentally arises from indirect addressing and nothing new.
So how do you juggle PC to do it.
(5) how does it compare to and superior to a function or subroutine
call. how does it differ.
Basically, there is no difference to function/subroutine call. The
difference is just that there is no "call stack": the dynamic context
for a call is created on the heap and is garbage-collected when it is
no longer accessible. A continuation is just a reference to the state
of the current dynamic context. As long as a continuation remains
accessible, you can return to it as often as you like.
George Neuner said:Yes and no. General continuations, as you describe, are not the
only form continuations take. Nor are they the most common form
used. The most common continuations are function calls and returns.
Upward one-shot continuations (exceptions or non-local returns) are
the next most common form used, even in Scheme.
Upward continuations can be stack implemented. On many CPU's, using
the hardware stack (where possible) is faster than using heap
allocated structures. For performance, some Scheme compilers go to
great lengths to identify upward continuations and nested functions
that can be stack implemented.
David Kastrup said:There is a Scheme implementation (I keep forgetting the name) which
actually does both: it actually uses the call stack but never returns,
and the garbage collection includes the stack.
Matthias Benkard said:continuations. There used to be a project called Stackless Python that
tried to add continuations to Python, but as far as I know, it has always
been separate from the official Python interpreter. I don't know whether
it's still alive. You may want to check http://stackless.com/
Instead of function A returning to its caller, the
caller provides an additional argument (the "continuation") which is a
function B to be called by A with A's result(s).
That's just a callback. I've been doing that in C code (and other
similar-level languages) for years.
Want to reply to this thread or ask your own question?
You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.