Why function which uses the setcdr modifies its argument? and how to avoid?

Question

I thought function in elisp can't modify its argument, but it is not true when some special primitive functions such as setcar/setcdr/delq/delete (not including setq) are called when defining new function in elisp, for example, in following the value of x gets changed after calling (foo x), which is not unexpected and undesired to me.

(defun foo (x) (setcdr x nil))

(progn (setq x '(1 2))
       (foo x)
       x)
;; => (1)

I know I can make a copy of x before using setcar to avoid the problem, is this the right way?

Besides, It also looks like it is impossible to write a setcar implementation in elisp function.

---

It bothered me when I was writing my-insert-nth, I had to make a copy of argument list in function body since list's value should be changed, while I'm not quite sure.

(defun my-insert-nth (list element n)
  "Insert ELEMENT at Nth of LIST."
  (if (<= n 0)
      (nconc (list element) list)
    (let ((len (length list)))
      (if (>= n len)
          (append list (list element))
        ;; FIXME: Why need another copy? Does `defun' already do that?
        (let ((new-list (copy-sequence list)))
          (setcdr (nthcdr (1- n) new-list) (cons element (nthcdr n new-list)))
          new-list)))))

(let ((l '(a b c)))
  (list (my-insert-nth l 'beg 0)
        (my-insert-nth l 'mid 2)
        (my-insert-nth l 'end 3)))
;; => ((beg a b c)
;;     (a b mid c)
;;     (a b c end))

Answer 1

When passing a list to a function, you pass that list, not a copy of it. If the function you are calling modify the list, the list is modified for anybody having that list.

(Technically, a list consists of cons pairs, and you pass the topmost cons pair to the function.)

If you write a lisp function, you have to choice to make it destructive or value based. However, if you make it destructive, you must document it very clearly.

In your case, however, you don't have to copy the entire list. Anything after the element you would like to set can refer to the tail of the original list.

EDIT: the following code use cl-subseq to copy the start of the list. It is destructively joined with the rest of the list using nconc, this is fine since we're operating on a new list that no one else can have access to. Also, the 0 case has been simplified, all you need to do is to add the new element to the front of the list using cons.

(defun my-insert-nth (list element n)
  (if (<= n 0)
      (cons element list)
    (nconc (cl-subseq list 0 n)
           (cons element (nthcdr n list)))))