[Python-Dev] 'stackless' python?

[Guido van Rossum]

Sam (& others),

I thought I understood what continuations were, but the examples of
what you can do with them so far don't clarify the matter at all.

Perhaps it would help to explain what a continuation actually does
with the run-time environment, instead of giving examples of how to
use them and what the result it?

Here's a start of my own understanding (brief because I'm on a 28.8k
connection which makes my ordinary typing habits in Emacs very
painful).

1. All program state is somehow contained in a single execution stack.
This includes globals (which are simply name bindings in the botton
stack frame).  It also includes a code pointer for each stack frame
indicating where the function corresponding to that stack frame is
executing (this is the return address if there is a newer stack frame, 
or the current instruction for the newest frame).

2. A continuation does something equivalent to making a copy of the
entire execution stack.  This can probably be done lazily.  There are
probably lots of details.  I also expect that Scheme's semantic model
is different than Python here -- e.g. does it matter whether deep or
shallow copies are made?  I.e. are there mutable *objects* in Scheme?
(I know there are mutable and immutable *name bindings* -- I think.)

3. Calling a continuation probably makes the saved copy of the
execution stack the current execution state; I presume there's also a
way to pass an extra argument.

4. Coroutines (which I *do* understand) are probably done by swapping
between two (or more) continuations.

5. Other control constructs can be done by various manipulations of
continuations.  I presume that in many situations the saved
continuation becomes the main control locus permanently, and the
(previously) current stack is simply garbage-collected.  Of course the 
lazy copy makes this efficient.



If this all is close enough to the truth, I think that continuations
involving C stack frames are definitely out -- as Tim Peters
mentioned, you don't know what the stuff on the C stack of extensions
refers to.  (My guess would be that Scheme implementations assume that
any pointers on the C stack point to Scheme objects, so that C stack
frames can be copied and conservative GC can be used -- this will
never happen in Python.)

Continuations involving only Python stack frames might be supported,
if we can agree on the the sharing / copying semantics.  This is where 
I don't know enough see questions at #2 above).

--Guido van Rossum (home page: http://www.python.org/~guido/)