Using case to compare with a variable

Question

I expected the outcome of the following small program:

(progn
  (setq x 1)
  (case x
    (x 'Yes)
    (t 'No)))

to be Yes, given that case compares things with eql, and surely x is eql to itself. However the outcome is No and I am completely puzzzled by this!

---

---

This is a long comment, not an answer!

Thanks to everybody for making everything perfectly clear. My original intention was to use 'case' to simulate something like

(cond
  ((equal x a) 'this)
  ((equal x b) 'that)
  ((equal x c) 'something-else))

which would look much cleaner if it were equivalent to

(case x
  (a 'this)
  (b 'that)
  (c 'something-else))

But, alas, I understand that these are not equivalent forms due to the fact that case evaluates x but does not evaluates the keys in each clause.

I thought of faking things, such as in

(let ( (x 2) (a 1) (b 2) (c 3) ) (flet ( (eql (x y) (equal x (eval y))) )
  (case x
    (a 'this)
    (b 'that)
    (c 'something-else))
))

which does work as I'd like but I suppose it is a bit blasphemous to alter the meaning of something as basic as 'eql', even if only temporarily!

Answer 1

1. case is an alias for cl-case, so there is no difference, there.

2. This aspect of the behavior is the same in Common Lisp.

3. There is nothing very weird here. You just need to read the doc, which tells you that the first arg to case is evaluated and the result is compared with the car entries of the following lists. cl-case is a macro, so in general (i.e., unless told otherwise) you can suppose that it does not evaluate its arguments.

4. But perhaps the doc should explicitly point out that nothing in those lists is evaluated - only the first argument is evaluated.

5. More generally wrt the doc: This is an emulation of case in Common Lisp. The doc for case in Common Lisp itself is very clear: either the hyperspec or (especially) Common Lisp the Language.

6. Unfortunately nearly ALL of the Emacs emulation of Common-Lisp stuff is poorly documented. One really has to check the Common-Lisp doc to understand what it is that Emacs is trying to emulate - and then guess the ways in which it doesn't succeed in emulating this or that bit.

7. Perhaps this is really what you were trying to do (just a guess):

   (case x
     (1 'Yes)
     (t 'No))
   

Answer 2

BTW, I recommend the use of pcase, which is more powerful. The equivalent code to what you wrote, would be:

(let ((x 1))
  (pcase x
    ('x 'Yes)
    (_ 'No)))

Making it clear that x is not evaluated. This said, it would probably confuse you as well, because if you naively write:

(let ((x 1))
  (pcase x
    (x 'Yes)
    (_ 'No)))

it will tell you Yes but for the wrong reason: the x pattern matches anything (not just the value held in variable x) and it then re-binds a new variable x, so

(let ((x 1))
  (pcase 5
    (x x)
    (_ 'No)))

would return 5. But with pcase you can do the test you want, which is written in a significantly more verbose way:

(let ((x 1))
  (pcase x
    ((pred (eql x)) 'Yes)
    (_ 'No)))

Answer 3

The first part of each clause in a case form is a value (or a list of values), not an expression. The x before 'Yes is syntactically interpreted as a value. The x after case, on the other hand, is interpreted as an expression, i.e. it is evaluated; its value is 1. The value 1 (which is an integer) is not equal to the value x (which is a symbol). Contrast:

• (case x (x 'Yes) (t 'No)) → No   (1 ≠ x)
• (case 'x (x 'Yes) (t 'No)) → Yes   (x = x)
• (case x (1 'Yes) (t 'No)) → Yes   (1 = 1)

case is meant to be similar to case statements in most other languages, which compares the value of an expression against some constants. Each clause of a case statement specifies a constant (i.e. something that is already in the form of a value in the source code) to compare against the value of the expression.

(case (+ x y)
  (1 "one")
  (2 "two")
  ((3 4) "many")    ; instead of a single value, a clause can have a list of values
  (t "lots"))

If you want to test whether the value of an expression is equal to the value of one of several expressions, then you're doing something more complicated than what case can offer. Using cond is perfectly reasonable.

https://www.gnu.org/software/emacs/manual/html_node/cl/Conditionals.html#index-cl_002dcase-32