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

Defining the forms to which the # constructs expand

I agree with you, since I think that primitives should always be available
to the user.

Note, however, that you both missed a vital point.  Neither #. nor #,
expands into a form!  Both of these can be used inside of an expression
which is data, as well as inside an expression which is a program.  When
reading into the environment (as opposed to reading into the compiler),
the #. and #, constructs must produce precisely the result of evaluating
their argument.  They cannot produce any sort of "wrapper" around it.

The only hidden primitive involved in #. and #, is the "magic wrapper"
that #, uses when reading into the compiler.

The inability to deal with things like #. is the inherent bankruptcy of
residential systems, if by that you mean an editor which regenerates your
source text from the actual contents of memory, rather than keeping a
separate copy of it.  On the other hand, if by residential system you mean
merely the ability to switch rapidly between typing at the Lisp evaluator
and typing at the editor, and the ability to edit single functions and get
them into memory without the overhead of reading or compiling whole files,
this is what we have in the Lisp machine, while still using text-based
editing, and Boy!  Is it ever an improvement over the old file-based ways
of doing things!