[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Internals Proposal

I'd like to make clear that the proposal I made in the previous post only
solves the problem of how applications (and lisp itself) communicate with
arbitrary instances, assuming they subscribe to this view.  All that is needed
is to define the messages that must be understood by the instances.  For
standard object systems, the translation (done by the sending function) from
these standard messages to object system messages will be minimal; other
applications may want to use an eq hashtable somehow (which should be fast).

Applications that only deal with one kind of object should of course use the
sending primitive, rather than lisp:send.  If speed is not important and there
is a chance the code might want to be applied to objects of other systems, you
might consider using lisp:send.

Other proposals will have to deal with the separate issues of instance
variables, fast handler lookup, etc. As for whether such things are suitable
for white-pageness, I'm not sure.  The Flavors kernel (being written) deals
with instance variables, but has to tie these up with all sorts of other things
(instance environments, method inheritance and hence method dependencies, etc).
It's sort of strange in that some basic language functions are being altered by
non-white-pages forms (e.g. (setq instance-variable 3) works inside a
defmethod), but everything's hunky dory if you think of the defining forms
(e.g. defmethod) as macros that torture the code.