The 'case' special form first evaluates 'expr', the return value of this evaluation is then compared against all the 'value' entries:
(case expr
(value-1 action-1)
(value-2 action-2)
...
(value-n action-n))
If 'value' is a single atom, the atom is compared against 'expr':
> (case 'a
('a "a")
('b "b"))
"a"
If 'value' is a list, each of the elements of the list are compared against 'expr':
> (case 'a
((1 2 3 4) "number")
((a b c d) "alpha"))
"alpha"
The 'action' associated with the first 'value' that matches 'expr' is evaluated and returned as the result of the 'case' special form.
If no 'value' matches, NIL is returned:
> (case 'c
('a "a")
('b "b"))
NIL
If the last 'value' is the symbol T and
no other 'value' has matched 'expr', then 'case' will evaluate the 'action'
associated
> (case 3
(1 "one")
(2 "two")
(t "no match"))
"no match"
If there are multiple T entries, the first is considered to be the end of the 'case':
> (case 9
(1 "one")
(t "first t")
(t "second t"))
"first t"
Note: The 'case' special form does not work with a list or string as the 'expr' because 'case' uses eql which cannot compare lists or strings:
> (case "a" ; doesn't work!
("a" 'a)
("b" 'b))
NIL
The cond special form can be used to test Lisp expressions that cannot be handled by 'case'.
(case) => NIL
(case 'a) => NIL
(defun c-type (expr)
(case (type-of expr)
(flonum "float")
(fixnum "integer")
(string "string")
(cons "non-empty list")
(nil "empty list")
(t "other")))
(c-type 1.2) => "float"
(c-type 3) => "integer"
(c-type "ab") => "string"
(c-type '(a b)) => "non-empty list"
(c-type '()) => "empty list"
(c-type 'a) => "other"
See also: