when to quote symbol in Emacs Lisp - emacs

Question

I've beginning learning programming with Emacs Lisp. I'm so confused by symbol quotation.
For example:
(progn
(setq a '(1 2))
(prin1 a)
(add-to-list 'a 3)
(prin1 a)
(setcar a 4)
(prin1 a)
(push 5 a)
""
)
why the "add-to-list" function need a quoted symbol as its first argument, while the "setcar" and "push" function need no argument quotation?

Answer 1

Here's a diagram that represents the symbol a and its value after (setq a '(1 2)). The boxes are elementary data structures (symbols and conses) and the arrows are pointers (where a piece of data references another). (I'm simplifying a little.)
symbol cons cons
+-------+----------+ +------+------+ +------+------+
|name: |variable: | |car: |cdr: | |car: |cdr: |
| a | | | | 1 | | | | 2 | nil |
+-------+----|-----+ +------+--|---+ +------+------+
| ​↑ | ↑
+-------------+ +-------+
The expression '(1 2) builds the two conses on the right, which make up a two-element list. The expression (setq a '(1 2)) creates the symbol a if it doesn't exist, then makes its “variable slot” (the part that contains the value of the symbol) point to the newly created list. setq is a built-in macro, and (setq a '(1 2)) is shorthand for (set 'a '(1 2)). The first argument of set is the symbol to modify and the second argument is the value to set the symbol's variable slot to.
(add-to-list 'a 3) is equivalent to (set 'a (cons 3 a)) here, because 3 is not in the list. This expression does four things:
Create a new cons cell.
Set the new cons cell's car field to 3.
Set the new cons cell's cdr field to the former (and still current) value of a (i.e. copy the contents of a's variable slot).
Set the variable slot of a to the new cons cell.
After that call, the data structures involved look like this:
symbol cons cons cons
+-------+----------+ +------+--|---+ +------+------+ +------+------+
|name: |variable: | |car: |cdr: | |car: |cdr: | |car: |cdr: |
| a | | | | 3 | | | | 1 | | | | 2 | nil |
+-------+----|-----+ +------+--|---+ +------+--|---+ +------+------+
| ​↑ | ↑ | ↑
+-------------+ +-------+ +-------+
The call to setcar doesn't create any new data structure, and doesn't act on the symbol a but on its value, which is the cons cell whose car currently contains 3. After (setcar a 4), the data structures look like this:
symbol cons cons cons
+-------+----------+ +------+--|---+ +------+------+ +------+------+
|name: |variable: | |car: |cdr: | |car: |cdr: | |car: |cdr: |
| a | | | | 4 | | | | 1 | | | | 2 | nil |
+-------+----|-----+ +------+--|---+ +------+--|---+ +------+------+
| ​↑ | ↑ | ↑
+-------------+ +-------+ +-------+
push is a macro; here, (push 5 a) is equivalent to (set 'a (cons 5 a)).
setq and push are macros (setq is a “special form”, which as far as we're concerned here means a macro whose definition is built into the interpreter and not provided in Lisp). Macros receive their arguments unevaluated and can choose to expand them or not. set, setcar and add-to-list are functions, which receive their arguments evaluated. Evaluating a symbol returns the contents of its variable slot, e.g. after the initial (setq a '(1 2)) the value of the symbol a is the cons cell whose car contains 1.
If you're still confused, I suggest experimenting with (setq b a) and seeing for yourself which of the expressions modify b when you act on a (the ones that act on the symbol a) and which don't (the ones that act on the value of the symbol a).

Answer 2

Functions evaluate their arguments before execution, so quote when you need to pass an actual symbol (as pointer to some data structure, for example) and don't quote when it's a variable value.
add-to-list performs in-place mutation of its first argument, so it needs a quoted symbol.
push is not a function, but a macro; that is why it's able to accept unquoted arguments without evaluation. Builtin forms, like setcar, also do not have that limitation.

Answer 3

The other answers given so far clarify the use of quote and the difference between functions, on the one hand, and macros and special forms on the other hand.
However, they do not get to another part of the question: why is add-to-list as it is? Why does it require its first argument to be a symbol? That's a separate question from whether or not it evaluates the argument. It's the real question behind the design of add-to-list.
One could imagine that add-to-list evaluated its args, and expected the value of the first arg to be a list, and then added the value of the second arg to that list as an element and returned the result (new list or same list). That would let you do (add-to-list foo 'shoe) to add the symbol shoe to the list that is the value of foo -- say (1 2 buckle) --, to give (1 2 buckle shoe).
The point is that such a function would not be very useful. Why? Because the list value isn't necessarily accessible. The variable foo might be thought of as a way to access it -- a "handle" or "pointer" to it. But that is not true of the list that the function returns. That returned list can be composed of new list structure, and there is typically nothing (no variable) pointing to that list. The function add-to-list never sees the symbol (variable) foo -- it has no way of knowing that the list value it receives as first argument is bound to foo. If add-to-list were designed that way then you would still need to assign its returned result to your list variable.
IOW, add-to-list evaluates its args because it is a function, but that doesn't explain much. It expects a symbol as the value of its first arg. And it expects the value of that variable (symbol) to be a list. It adds the value of its second arg to the list (possibly changing the list structure), and it sets the value of the variable that is the value of its first arg to that list.
Bottom line: It needs a symbol as arg because its job is to assign a new value to that symbol (the new value being the same list value or the same value with the new list element added at the front).
And yes, another way to go would be to use a macro or special form, as in push. It's the same idea: push wants a symbol as its second arg. The difference is that push does not evaluate its args so the symbol need not be quoted. But in both cases (in Emacs Lisp) the code needs to get hold of a symbol in order to set its value to the augmented list.