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/)