Proper reinitialization of a list? What is happening under the hood?

Question

I'm teaching myself some more elisp and have encountered the following problem:

If I want to reset a list variable it won't get updated after the first evaluation. Here is some example code:

(defun initilize ()
  (setq example '(3)))

(defun modify ()
  (initilize)
  (message "%S" example)
  (setcar example 2))

; M-x eval-buffer RET
(modify) ; message --> (3)
(modify) ; message --> (2)
(modify) ; message --> (2)

I'm interested in two things. The first is to learn more about what is happening "under the hood" so why does it work the first time and fails on subsequent calls?

The second and more practical question is how to reinitialize the list properly or is there another common way of doing something like that?

One workaround I found myself is to use a quoted list and evaluating the content like this:

(setq example `(,3)) 

Answer 1

You can use (setq example (list 3)) to avoid this error.

What happens is init assigns an object that initially contains (3) to example. It sets the value of the object only once. Subsequently, you modify this value.

Here's your example in C++, if you understand that better:

#include <stdio.h>
#include <string.h>
char* example;
char* storage = 0;
char* create_object_once (const char* str) {
  if (storage == 0) {
    storage = new char[strlen (str)];
    strcpy (storage, str);
  }
  return storage;
}
void init () {
  example = create_object_once ("test");
}
void modify () {
  init ();
  printf ("%s\n", example);
  example[0] = 'f';
}
int main (int argc, char *argv[]) {
  modify ();
  modify ();
  modify ();
  return 0;
}

Answer 2

Maybe this will clear up some of the confusion:

• Your function initilize does not initialize variable example. It sets it to a particular cons cell - the same cons cell each time it is called. The first time initilize is called, the setq assigns example to a new cons cell, which is the result of evaluating '(3). Subsequent calls to initilize just reassign example to the same cons cell.

• Since initilize just reassigns the same cons cell to example, modify just sets the car of that same cons cell to 2 each time it is called.

• To initialize a list, use list or cons (or an equivalent backquote sexp, such as `(,(+ 2 1)) or `(,3)). For example, use (list 3).

The key to understanding this is to know that a quoted cons cell is evaluated only once, and thereafter the same cons cell is returned. This is not necessarily the way that all Lisps behave, but it is how Emacs Lisp behaves.

More generally, the behavior of evaluating a quoted mutable object is implementation dependent, if not language dependent. In Common Lisp, for example, I'm pretty sure that there is nothing in the definition (spec) of the language that defines the behavior in this regard - it is left up to the implementation.

Summary: Do not expect '(some list) to be eq to '(some list) - ever.There is generally no guarantee in Lisp that code that visibly quotes a list returns new list structure each time. In some Lisp implementations it might, or it might some of the time. In others, it never does. Your code should anyway not depend on any such behavior from the implementation. If you want new list structure, use list or cons or equivalent.