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

Issue: APPEND-DOTTED (Version 5)

This issue was withdrawn, along with the ones it spawned: APPEND-ATOM and

At the time, I believe I said we would consider whether we wanted to submit
a more comprehensive set of proposals that would address all of the issues

I personally have no desire to do so.

I believe that the sentence Problem Description that claims that CLtL is
not adequately clear is incorrect, namely, that elsewhere in CLtL it states
that if an argument is supposed to be a LIST, it means a PROPER LIST unless
otherwise stated. In the case of APPEND, the only case that otherwise
states so is the last argument, and thus, CLtL does specify that it "is an
error" to pass an atom or a dotted list to APPEND as any argument except
the last.

Issue:        APPEND-DOTTED
References:   APPEND (p268)
Edit history: 27-Jul-87, Version 1 by Pitman
              29-Oct-87, Version 2 by Pitman (loose ends)
              14-Nov-87, Version 3 by Masinter
              23-Nov-87, Version 4 by Masinter
              14-Jan-88, Version 5 by Masinter

Problem Description:

The description of APPEND on p268 is not adequately clear on the issue of
what happens if an argument to APPEND is a dotted list. The only case
explicitly mentioned is the last argument, viz:

"The last argument [to APPEND] actually need not be a list but may be any
LISP object, which becomes the tail end of the constructed list. For
example, (append '(a b c) 'd) => (a b c . d)."

While this specifies the behavior of APPEND when the last argument is not a
list, the behavior when any of the other arguments are not lists is not


Define that the cdr of the last cons in any but the last argument given to
APPEND or NCONC is discarded (whether NIL or not) when preparing the list
to be returned.

In the degenerate case where there is no last cons (i.e., the argument is
NIL) in any but the last list argument, clarify that the entire argument is
effectively ignored. Point out that in this situation, if the last argument
is a non-list, the result of APPEND or NCONC can be a non-list.

Remove any text which suggests that (APPEND x '()) and (COPY-LIST x) are
the same, since these two might legitimately differ in situations involving
dotted lists. As such, deciding which to use is not just a stylistic issue.


(APPEND '(A B C . D) '())       => (A B C)	;Proposed
(NCONC (LIST* 'A 'B 'C 'D) '()) => (A B C)	;Proposed

Note that (COPY-LIST '(A B C . D)) would still return (A B C . D).

(APPEND '(A B . C) '() 3)       => (A B . 3)	;Proposed
(NCONC (LIST* 'A 'B 'C) '() 3)  => (A B . 3)	;Proposed

(APPEND '() 17)   => 17			;Proposed
(NCONC (LIST) 17) => 17			;Proposed


This function is used a lot and its behavior should be well-defined across
implementations. This proposal upholds the apparent status quo in a number
of implementations.

Current Practice:

Symbolics Lisp, Vaxlisp, and Lucid Lisp appear to implement the proposed
interpretation (at least in the interpreter). Franz's Allegro Common Lisp
conforms to the proposed behavior except in the case of (NCONC (LIST) 17)
=> 17, where it returns NIL instead of 17.

Kyoto Common Lisp signal an error when using APPEND or NCONC on a dotted
list. Xerox Common Lisp signals an error on APPEND and implements the
proposed interpretation on NCONC.

Cost to implementors:

Technically, the change should be relatively small for those
implementations which don't already implement it. However, implementations
which have microcoded APPEND or NCONC incompatibly may find the small
change somewhat painful.

Some implementations may have optimized their APPEND or NCONC to expect
only NIL when SAFETY is 0. In this case, depending on implementation
details, requiring an ATOM check rather than a NULL check may slow things

Cost to users:

This change is upward compatible.


Since non-lists are allowed as a last argument and since APPEND and NCONC
can therefore produce dotted lists, some readers may have (incorrectly)
assumed that APPEND and NCONC can reliably deal in general with dotted
lists, something that doesn't appear to be guaranteed by a strict reading.
The proposed extension would happen to legitimize such assumptions.


Whether or not users will think this improves the aesthetics of the
language will depend largely on how they view the relation between lists
and dotted lists. Those who view dotted lists as a special kind of list may
feel differently than those who view lists as a special kind of dotted


The cleanup committee supports this proposal.