LISP uses the self-evaluating symbol nil to mean false. Anything other
than nil means true. Unless we have a reason not to, we usually use the
self-evaluating symbol t to stand for true.
LISP provides a standard set of logical functions, for example
and, or,
and not. The and and or connectives are
short-circuiting: and will not
evaluate any arguments to the right of the first one which evaluates to
nil, while or will not evaluate any arguments to the right
of the first
one which evaluates to t (with t we mean here ``non-nil'').
LISP also provides several special forms for conditional execution. The
simplest of these is if. The first argument of if determines whether
the second or third argument will be executed:
> (if t 5 6)
5
> (if nil 5 6)
6
> (if 4 5 6)
5
If you need to put more than one statement in the then or else clause
of an if statement, you can use the progn special
form. Progn executes
each statement in its body, then returns the value of the final one.
> (setq a 7)
7
> (setq b 0)
0
> (setq c 5)
5
> (if (> a 5)
(progn
(setq a (+ b 7))
(setq b (+ c 8)))
(setq b 4))
13
An if statement which lacks either a then or an else clause can be
written using the when or unless special form:
> (when t 3)
3
> (when nil 3)
NIL
> (unless t 3)
NIL
> (unless nil 3)
3
When and unless, unlike if, allow any number of
statements in their
bodies. (Eg, (when x a b c) is equivalent to
(if x (progn a b c)).)
> (when t
(setq a 5)
(+ a 6))
11
More complicated conditionals can be defined using the cond special
form, which is equivalent to an if ... else if ... fi construction.
A cond consists of the symbol cond followed by a number of cond
clauses, each of which is a list. The first element of a cond clause is
the condition; the remaining elements (if any) are the action. The cond
form finds the first clause whose condition evaluates to true (ie,
doesn't evaluate to nil); it then executes the corresponding action and
returns the resulting value. None of the remaining conditions are
evaluated; nor are any actions except the one corresponding to the
selected condition. For example:
> (setq a 3)
3
> (cond
((evenp a) a) ;if a is even return a
((> a 7) (/ a 2)) ;else if a is bigger than 7 return a/2
((< a 5) (- a 1)) ;else if a is smaller than 5 return a-1
(t 17)) ;else return 17
2
If the action in the selected cond clause is missing, cond returns what
the condition evaluated to:
> (cond ((+ 3 4)))
7
Here's a clever little recursive function which uses cond. You might be
interested in trying to prove that it terminates for all integers x at
least 1. (If you succeed, please publish the result.)
> (defun hotpo (x steps) ;hotpo stands for Half Or Triple Plus One
(cond
((= x 1) steps)
((oddp x) (hotpo (+ 1 (* x 3)) (+ 1 steps)))
(t (hotpo (/ x 2) (+ 1 steps)))))
A
> (hotpo 7 0)
16
The LISP case statement is like a C switch statement:
> (setq x 'b)
B
> (case x
(a 5)
((d e) 7)
((b f) 3)
(otherwise 9))
3
The otherwise clause at the end means that if x is not a,
b, d, e, or f, the case statement will return 9.