Sat Aug 8 10:22:47 CEST 2009
letcc -> apply
It seems better to stick with the way things work right now, and use
only a single type of primitive. This makes integration with C (the
eventual goal) a lot easier, and will prevent a lot of if-type style
With `letcc' implemented as a special form, it is now possible to
create primitives that operate on continuations as data, creating new
continuations. These values can themselves be applied. This means
`apply' can be implemented as a continuation modification followed by
Yes, but. The current k_apply type is a bit awkward, because it
evaluates from left to right, it will wait for the final argument
before coninuing with application. Maybe it's simplest to support a
right-to-left app frame?
Before continuing, let's make the continuations somewhat abstract:
each with a parent slot in the first position.
One way is to have a reverse k_apply: one that traverses the arguments
from right to left. This way the `apply' continuation can be
constructed as an argument list, with the function value passed to it.
This would either require an extra reverse, or some re-arrangement in
the primitive call trampoline.
Or, a different kind of continuation could be made that ignores its
value, but passes closure to its parent continuation.
Basicly, such a continuation takes a value, ignores it, and passes
another value to its parent continuation.
Actually, this already exists: k_seq.
Indeed: Using a continuation like this:
_ -> (fn a1 a2 (begin _ a3))
will also ignore the supplied value and reduce to (fn a1 a2 a3).