> Distinguishing between general
> escape procedures and use-once-only escape procedures would help a whole
> lot.

Has anyone formulated a proposal along these lines?

Is it possible to simulate a one-shot escape procedure by keeping a
`have-i-run-yet?` variable in the closure?

> I have believed for a long time that goroutines (which can be
> implemented on top of SRFI 18) are in some sense the Right Thing.  See
> <http://wiki.call-cc.org/eggref/5/gochan>.  That way you can get
> shared-almost-nothing (with some self-discipline) with the intra-process
> analogue of pipes, which are a very nice way to provide concurrency.

Indeed on Unix at the C level, it's surprising how often pipes are the
way to do things. You can even treat a pipe as shared memory with
built-in locking and synchronization if you don't need to share a lot of
data. It's easier, more portable and reliable than the shm APIs.

Aren't goroutines basically a lightweight version of Erlang IPC, or have
I misunderstood something about both languages?

> You don't need await/async decorators in Scheme because we have ... call/cc!

Can you (or someone else) share some patterns of continuation usage that
would be useful for web programming (in the browser) if we can compile
them into some form that's acceptable to JavaScript? I'm out of my depth
here and don't know where to look.

> Yes, tail *recursion* is easy to do with loops and jumps.  It's
> *general* tail calls (to arbitrary procedures) that are hard.

Would those be important for good performance in-browser? Almost all
tail calls I use are tail recursion. Does this general tail call
optimization you have in mind have something to do with translating code
into continuation-passing style for compilation, and compiling that
style into fast code? The shallowness of my compiler knowledge really
shows here.