[CL.BOYER@UTEXAS-20.ARPA: defmacro]

["David A. Moon" <Moon@SCRC-STONY-BROOK.ARPA>]

    Date: Thu, 20 Dec 84 17:31 EST
    From: "David A. Moon" <Moon@SCRC-STONY-BROOK.ARPA>

    I don't know why cl-iteration is the right group on which to discuss this,
    but let that pass.

	Date: Mon 10 Dec 84 10:54:51-EST
	From: STEELE@TL-20A.ARPA

	Date: Sun, 9 Dec 1984  16:38 CST
	From: CL.BOYER@UTEXAS-20.ARPA

	Finally, and totally unrelatedly, is it true that

	     (defmacro foo x ...)

	is not permited in Common Lisp and that
	I need to write

	     (defmacro foo (&whole x) ...)?

	I'm trying to find some common ground with psl and the maclisp
	dialects, but it doesn't look like there is a general
	purpose intersection.  As I read it, a lambda list has
	to be a list, and that excludes a symbolp.

	P.S. Hedrick's 2060 Common Lisp permits (defmacro foo x ...).

    Our defmacro treats (defmacro foo x ...) as equivalent to
    (defmacro foo (&rest x) ...) rather than (defmacro foo (&whole x) ...).
    Which interpretation does Hedrick's use?

    I guess this ambiguity makes it quite clear why Common Lisp doesn't allow it.

Since Boyer later explained that his &WHOLE was a typo for &REST, it seems that
there is only one proposed meaning for (defmacro foo x ...).  Furthermore, the
generalization from (defmacro foo ((&rest x)) ...) = (defmacro foo (x) ...)
to (defmacro foo (&rest x) ...) = (defmacro foo x ...) seems like a natural one
for users to assume.

Should this be moved off of cl-iteration and proposed to common-lisp at large?
I don't care much, personally.