Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Path: utzoo!watmath!clyde!caip!ut-sally!utah-cs!utah-orion!shebs
From: shebs@utah-orion.UUCP (Stanley Shebs)
Newsgroups: net.lang.lisp
Subject: Re: Common Lisp
Message-ID: <136@utah-orion.UUCP>
Date: Thu, 3-Jul-86 19:12:51 EDT
Article-I.D.: utah-ori.136
Posted: Thu Jul  3 19:12:51 1986
Date-Received: Fri, 4-Jul-86 08:21:56 EDT
References: <1023@h.cs.cmu.edu>
Reply-To: shebs@utah-orion.UUCP (Stanley Shebs)
Distribution: net
Organization: University of Utah CS Dept
Lines: 44

In article <1023@h.cs.cmu.edu> shivers@h.cs.cmu.edu (Olin Shivers) writes:

>You could argue that this constitutes compilation, albeit a very cheap,
>fast compilation that preserves the original form of the source.  True.
>But it retains the interpreter and all the advantages thereof.  Some lisps
>actually use this technique -- the first thing the interpreter does is (1)
>expand all macros, and (2) resolve all variable references.  Then the
>resulting code tree is interpreted quite speedily.  It's a real win.

A small caveat for all those who want to run out and do this in their
interpreters - users don't really like to look at their macroexpanded code!
(symbol-function 'foo) returns something that has little apparent relation
to what was typed in.  Implementations that do this need to provide some
way of looking at the original input, for instance by hanging on to the
source code and using a debugger to display it, just as for incrementally
compiled Lisps.

>The package system is a horrible solution to a real problem.

The poor package system - everybody hates it, but nobody wants to
chuck it.  The only serious alternative I've heard suggested is
some sort of persistent lexical environment (locales in T), but I
don't view the package system as a way to screw around with mapping
of names to values, instead it's a way to increase the size of the
name space without increasing the average size of names.

>CL makes the classic lisp error of confusing symbols (a data type)
>with variables (a language level object). #' is a totally stupid idea. NIL
>should not be a list.

Hmmm, he sounds like a Schemer!  Actually, the most ultimate and purest Lisp
dialect I know of is 3-Lisp, which is so clean and regular that it makes
any Scheme look like a kludge.  Brian Smith pointed out that (for instance)
conses are used in a multitude of ways in most Lisps, while in 3-Lisp conses
are only used for function applications;  the "rail" data structure is
used for lists/sequences.  Quotes don't "fall off" as a result of evaluation;
as a result, one doesn't get the Lisp oddity (+ 2 '3) => 5.  Closures are
ordinary data structures with 4 slots.  Reflection gives one great power,
in fact it hasn't really been exploited yet.
3-Lisp is the way to go for true language purists.

>			    -Olin

								stan