From: Michael Werts
Subject: Quote syntax
Date: 
Message-ID: <Bxvq8r.E38@beach.csulb.edu>
In the design of Lisp was there a profound reason for using

    (QUOTE (+ 1 1)) or '(+ 1 1)

to inhibit evaluation instead of something like

    [+ 1 1] ?

--

MICHAEL WERTS -- ·····@csulb.edu
Computer Engineering Computer Science
California State University Long Beach

From: Brian Harvey
Subject: Re: Quote syntax
Date: 
Message-ID: <1ebsrlINNppi@agate.berkeley.edu>
·····@aardvark.cecs.csulb.edu (Michael Werts) writes:
>In the design of Lisp was there a profound reason for using
>    (QUOTE (+ 1 1)) or '(+ 1 1)
>to inhibit evaluation instead of something like
>    [+ 1 1] ?

Yes, the reason is that the Lisp notation allows a Lisp program to be
readable as Lisp data.  That is, (quote (+ 1 1)) is just an ordinary
Lisp list, so a Lisp program can read and manipulate it.  It's really
the same reason that you say (f x) and not f(x) -- the Lisp way makes
an expression readable as a list.

The notation '... is just an abbreviation for (quote ...) and is
converted to the latter form when read.

It would have been possible, I suppose, to make [...] abbreviate
quoting, but would [...] mean (quote (...)) or (quote ...)?  You
want a uniform notation that can quote symbols as well as lists.
If [+ 1 1] quotes (+ 1 1), how do you quote +?
From: Barry Margolin
Subject: Re: Quote syntax
Date: 
Message-ID: <1ed0vjINNeq5@early-bird.think.com>
Brian Harvey gave a good explanation of the justification for the Lisp
quoting style.  I just thought I'd mention that MDL, a derivative of Lisp,
did do something like what Michael Werts suggested.  In MDL there was a
separate data type called "form", used for invoking functions, macros, and
special forms.  Its syntax was <operator args>.  List notation, on the
other hand, was (elements), and were literals.  The list accessor functions
also accepted forms, and there were conversion functions for converting
lists to forms and vice versa.

Symbols were also self evaluating (to answer the question at the end of
Brian's posting).  There were special forms to access the local and global
value of a symbol, and reader macros ("." and ",", respectively) to
simplify the use of them.

Thus, the Lisp form (list a *a* 'b '(1 2 3)) would be <list .a ,*a* b (1 2
3)> in MDL.

This is all from ancient memory, so I may have some of the details wrong.
-- 
Barry Margolin
System Manager, Thinking Machines Corp.

······@think.com          {uunet,harvard}!think!barmar