http://dekorte.com/projects/opensource/libcoroutine/

EDIT: whoops, I meant to say continuations, as camccann was kind enough to point out.

Basically it works by letting you send a value into a generator function, which then appears as the return value of the most recent yield statement. I have abused this feature horribly at times to create cooperatively multitasking lightweight pseudo-threads. Good times, that.

What vanilla does not and likely never will have, that Stackless does allow, are full continuations, a.k.a. the Dark Lord of All Flow Control Structures.

I wouldn't call it "copious", necessarily. It's easily reusable, at least. My aforementioned cooperative multitasking hackery involved inheriting from a base "coroutine-able" class that, among other things, kept a per-instance execution stack that would be updated by the dispatching loop depending on the value yielded by the generator. The end result would look something like this:

  def foo(self):
      spam = 1
      while True:
          yield self.call(self.spam_and_eggs, spam)
          spam += 1

  def spam_and_eggs(self, spam):
      print ("spam, " * spam) + "and eggs"
      if spam >= 20:
          yield self.halt()
      else:
          yield self.wait(2)
      yield self.ret()

Other actions included a goto (clear the stack and jump to a new generator method), conditional waits (keep running the thread unless, say, 2 miliseconds have elapsed since it started this cycle), and "message passing" between threads (push something onto another instance's stack). The main downside was that stack traces from exceptions inside a faux-thread were singularly useless, though I was working on some debugging tools for code using it.

The guts of it amounted to maybe a few hundred lines of code, most of which is the dispatch loop and bookkeeping for message queues. One of these days I ought to clean it up and post the code on the web somewhere, but unfortunately I'm currently in a somewhat sticky spot and looking for work (and I fear that spending more time on things like building cooperative multitasking in Python than things to further my humdrum day-job career has not been a great help thus far).

I'm using it for my startup. Effortless, clean code.

Edit: This runs on the standard Python install; you don't need Stackless.

Horrible in C, but beautiful in languages with GC and lambdas.

http://swtch.com/libtask/