What does setcdr do to a list which is the return value of a function?

Question

If I have something like this,

(setq first (list 'a 'b 'c))
(setq second (list 'x 'y 'z))

;; I know the let binding makes little sense but 
;; I need it in the full version of the function.
(defun return-list (list)
  (let ((value list))
    value))

and I evaluate

(setcdr (return-list first) (append (return-list second)))

then what object does setcdr actually act on? On calling (return-list first) after the setcdr form I consistently get (a x y z). It seems to me that setcdr traces back first through the let binding and actually changes the value of the variable – indeed first itself evaluates to (a x y z) – but I'm not sure. The node about mutability on the Elisp manual says,

If a program attempts to change objects that should not be changed, the resulting behavior is undefined: the Lisp interpreter might signal an error, or it might crash or behave unpredictably in other ways.

When similar constants occur as parts of a program, the Lisp interpreter might save time or space by reusing existing constants or their components.

I'm not sure there isn't something that shouldn't be changed in my program. What I'd like to know is if I can rely on first always being (a x y z) after evaluating the setcdr form.

Answer 1

You shouldn’t think of setcdr as tracing anything back; it doesn’t have to do that. Both first and value refer to the same list, one which was created when the source code was read in. setcdr simply modifies whatever cons you give it, no matter where it came from or how you got ahold of it. It doesn’t care that you are modifying your own source code; it can’t even tell.

At some point you should copy the list, and then modify the copy. See the function cl-copy-list, for example. Or, you could create a copy yourself, and save the time needed to copy the bits that you don’t need. The code you included is equivalent to this:

(cons (car (return-list first))
      (return-list second))

This creates a new cons whose first element is the first element of first, and whose cdr refers to the list in second. This is a new cons that isn’t part of your source code, but note that the tail of this list is still shared with your source code. Depending on what you do later, maybe you want this instead:

(cons (car (return-list first))
      (cl-copy-list (return-list second)))

This creates a wholly new list.