12.8 Setting Variable Values

The usual way to change the value of a variable is with the special form setq. When you need to compute the choice of variable at run time, use the function set.

Special Form: setq [symbol form]…

This special form is the most common method of changing a variable’s value. Each symbol is given a new value, which is the result of evaluating the corresponding form. The current binding of the symbol is changed.

setq does not evaluate symbol; it sets the symbol that you write. We say that this argument is automatically quoted. The ‘q’ in setq stands for “quoted”.

The value of the setq form is the value of the last form.

(setq x (1+ 2))
     ⇒ 3
x                   ; x now has a global value.
     ⇒ 3
(let ((x 5))
  (setq x 6)        ; The local binding of x is set.
     ⇒ 6
x                   ; The global value is unchanged.
     ⇒ 3

Note that the first form is evaluated, then the first symbol is set, then the second form is evaluated, then the second symbol is set, and so on:

(setq x 10          ; Notice that x is set before
      y (1+ x))     ;   the value of y is computed.
     ⇒ 11
Function: set symbol value

This function puts value in the value cell of symbol. Since it is a function rather than a special form, the expression written for symbol is evaluated to obtain the symbol to set. The return value is value.

When dynamic variable binding is in effect (the default), set has the same effect as setq, apart from the fact that set evaluates its symbol argument whereas setq does not. But when a variable is lexically bound, set affects its dynamic value, whereas setq affects its current (lexical) value. See Scoping Rules for Variable Bindings.

(set one 1)
error→ Symbol's value as variable is void: one
(set 'one 1)
     ⇒ 1
(set 'two 'one)
     ⇒ one
(set two 2)         ; two evaluates to symbol one.
     ⇒ 2
one                 ; So it is one that was set.
     ⇒ 2
(let ((one 1))      ; This binding of one is set,
  (set 'one 3)      ;   not the global value.
     ⇒ 3
     ⇒ 2

If symbol is not actually a symbol, a wrong-type-argument error is signaled.

(set '(x y) 'z)
error→ Wrong type argument: symbolp, (x y)
Macro: setopt [symbol form]…

This is like setq (see above), but meant for user options. This macro uses the Customize machinery to set the variable(s) (see Defining Customization Variables). In particular, setopt will run the setter function associated with the variable. For instance, if you have:

(defcustom my-var 1
  "My var."
  :type 'number
  :set (lambda (var val)
         (set-default var val)
         (message "We set %s to %s" var val)))

then the following, in addition to setting my-var to ‘2’, will also issue a message:

(setopt my-var 2)

setopt also checks whether the value is valid for the user option. For instance, using setopt to set a user option defined with a number type to a string will signal an error.

Unlike defcustom and related customization commands, such as customize-variable, setopt is meant for non-interactive use, in particular in the user init file. For that reason, it doesn’t record the standard, saved, and user-set values, and doesn’t mark the variable as candidate for saving in the custom file.

The setopt macro can be used on regular, non-user option variables, but is much less efficient than setq. The main use case for this macro is setting user options in the user’s init file.