Hi, a few questions:
> A shallow thread is just a generator modified in the most obvious way > possible. The yield statement is replaced with a waitfor expression. > You give it the object you wish to "wait for". Then when it's ready > you get back a return value or an exception. These waitfor expressions > are the only points where your shallow thread may get suspended, so > it's always explicit. If you call another function it will be treated > exactly as a normal function call from a generator (this is why they're > 'shallow'), so there's no issues with calling C functions. > > On the other end of things, your shallow thread object would have > __resume__ and __resumeexc__ methods (or perhaps a single __resume__ > method with a default raise_=False argument). They return a tuple of > (mode,value) where mode is a string of 'waitfor', 'exception', or > 'return' and value corresponds to that. These methods will be used by > a main loop to resume the shallow thread, like next() is used with a > generator. So basically a shallow thread could be written in today's python like this? class ShallowThread(object): def __init__(self, data=None): self.data = data def run(self, initial_data=None): while True: .... yield <some_state> new_data = self.data .... st = ShallowThread().run(<some_initial_data>) while True: result = st.next() st.data = <some_subsequent_data> Basically <some_state> is your above mentioned tuple, and waitfor is like yield with a return value that I modeled with explicit state called data. Is that correct so far? > import mainloop, urllib > > def get_and_save(path): > infile = waitfor urllib.urlopen(path, async=True) > outfile = waitfor open(path.split('/')[-1], async=True) > waitfor outfile.write(waitfor infile.read(async=True), async=True) > infile.close() > outfile.close() > > def main(): > a = get_and_save("http://python.org/pics/PyBanner021.gif") > b = get_and_save("http://python.org/pics/pythonHi.gif") > c = get_and_save("http://python.org/pics/PythonPoweredSmall.gif") > > waitfor allDone(a, b, c) > > if __name__ == "__main__": > mainloop.runUntil(main()) > > Well there you have it. I've glossed over many details but they can be > cleared up later. What I need to know now is how everybody else thinks > about it. Is this something you would use? Does it seem like the > right way to do it? And of course the all important one, can I get it > in to python core? <0.5 wink> I've difficulties grasping where the actual work is done - the event notifier thingies are sort of generators themselves, and the mainloop gets them and calls some execute method on them? And now the final $1000,0000.00 question - why all this? No offense intended - it's a little bit more comfortable than the generators approach sketched by others (e.g. David Mertz if I recall corretly) - but to my view, it _could_ be done in today python because we have generators. Or not? -- Regards, Diez B. Roggisch -- http://mail.python.org/mailman/listinfo/python-list