Why does an elisp local variable keep its value in this case?

by

The Bad

test-a is self-modifying code. This is extremely dangerous. While the variable x disappears at the end of the let form, its initial value persists in the function object, and that is the value you are modifying. Remember that in Lisp a function is a first class object, which can be passed around (just like a number or a list), and, sometimes, modified. This is exactly what you are doing here: the initial value for x is a part of the function object and you are modifying it.

Let us actually see what is happening:

(symbol-function 'test-a)
=> (lambda nil (let ((x (quote (nil)))) (setcar x (cons 1 (car x))) x))
(test-a)
=> ((1))
(symbol-function 'test-a)
=> (lambda nil (let ((x (quote ((1))))) (setcar x (cons 1 (car x))) x))
(test-a)
=> ((1 1))
(symbol-function 'test-a)
=> (lambda nil (let ((x (quote ((1 1))))) (setcar x (cons 1 (car x))) x))
(test-a)
=> ((1 1 1))
(symbol-function 'test-a)
=> (lambda nil (let ((x (quote ((1 1 1))))) (setcar x (cons 1 (car x))) x))

The Good

test-b returns a fresh cons cell and thus is safe. The initial value of x is never modified. The difference between (setcar x ...) and (setq x ...) is that the former modifies the object already stored in the variable x while the latter stores a new object in x. The difference is similar to x.setField(42) vs. x = new MyObject(42) in C++.

The Bottom Line

In general, it is best to treat quoted data like '(1) as constants – do not modify them:

quote returns the argument, without evaluating it. (quote x) yields x.
Warning: quote does not construct its return value, but just returns
the value that was pre-constructed by the Lisp reader (see info node
Printed Representation). This means that (a . b) is not
identical to (cons 'a 'b): the former does not cons. Quoting should
be reserved for constants that will never be modified by side-effects,
unless you like self-modifying code. See the common pitfall in info
node Rearrangement for an example of unexpected results when
a quoted object is modified.

If you need to modify a list, create it with list or cons or copy-list instead of quote.

See more examples.

PS. This has been duplicated on Emacs.

PPS. See also Why does this function return a different value every time? for an identical Common Lisp issue.

More Related Contents:

  1. When should Emacs #’function syntax be used?
  2. eval-after-load vs. mode hook
  3. Using tramp with EmacsW32 and cygwin, possible?
  4. What’s in your .emacs?
  5. How to achieve code folding effects in Emacs?
  6. How to keep dir-local variables when switching major modes?
  7. Idiomatic batch processing of text in Emacs?
  8. How do I do closures in Emacs Lisp?
  9. Unexpected persistence of data [duplicate]
  10. Why does this function return a different value every time?
  11. Why does Ctrl+. not work when I bind it to a command in Emacs?
  12. How can I make Emacs start-up faster?
  13. Emacs: Symbol’s value as variable is void
  14. How to set the font size in Emacs?
  15. Setting Emacs to Split Buffers Side-by-Side
  16. How to tell emacs to open .h file in C++ mode?
  17. “Wrong type argument: commandp” error when binding a lambda to a key
  18. How can I more easily switch between buffers in Emacs?
  19. What to do if I cannot find my emacs init file?
  20. automatically disable a global minor mode for a specific major mode
  21. How to load program reading stdin and taking parameters in gdb?
  22. Using Emacs as an IDE
  23. Pin Emacs buffers to windows (for cscope)
  24. A gentle tutorial to Emacs/Swank/Paredit for Clojure
  25. Emacs: delete whitespaces or a word
  26. Unable to hide welcome screen in Emacs
  27. Emacs behind HTTP proxy
  28. Automatically closing braces in Emacs?
  29. Disable warning about emacs.d in load path
  30. Emacs: How to use a major mode for non-standard file extension

Leave a Comment