# CS 334: Lisp FAQ

This list should include all Lisp forms needed for the assignments.

### Atoms

t                    ;; true
nil                  ;; false
A, Cow, moo          ;; symbols


### Quoted Forms

'abc             ;; Unevaluated symbol
'(1 2 3)         ;; The list (1 2 3), which is not evaluated.  So:
(+ 1 2)  =>  3
'(+ 1 2)  =>  (+ 1 2)


### Boolean expressions

(eq x y)        ;; Returns t if x and y are the same number or
;; the same list.  Note: there are other equality
;; tests (eql, equals, etc.).  For 334, the distinctions
;; should be not important and eq should sufficient
;; for the problems we do.

(eq 1 1)  =>  t
(eq 1 2)  =>  nil
(eq 'A 'A)  =>  t
(eq 'A 'B)  =>  nil
(eq nil nil)  =>  t

(< x y)         ;; Arithmetic comparison.
;; (Other simple ops include: >, >=, or, and, not)

(< 1 2)  =>  t
(< 2 1)  =>  nil

(atom x)        ;; Return t if x is an atom and nil if x is a list

(atom 'A)  =>  t
(atom nil)  =>  t
(atom (car '(A nil)))  =>  t
(atom (cdr '(A nil)))  =>  nil

(member x l)    ;; Return nil if x is not in the list,
;; or t (or some other non-nil value) if x is
;; in the list.

(member 'A '(A B))  =>  t
(member 'C '(A B))  =>  nil


### Arithmetic expressions

(+ e1 ... en)   ;; Sum the numbers e1 ... en.  (*,-,/ are all similar)

(+ 1 2 3)  =>  6


Other operators include mod, sin, cose, etc.

                    (mod 7 3)  =>  1


### Lists

nil             ;; The empty list

(cons x ls)     ;; The list containing x, followed by the elements in ls

(cons 'A nil)  =>  (A)
(cons 'A (B))  =>  (A B)
(cons nil nil)  =>  (nil)

(car ls)        ;; The first element of the list ls

(car '(A B C))  =>  A
(car (cons A '(B C)))  =>  A

(cdr ls)        ;; The list ls, excluding the first element

(cdr nil)  =>  nil
(cdr '(A B C))  =>  (B C)
(cdr (cons A '(B C)))  =>  (B C)

(append l1 l2)  ;; The list containing the elements from l1,
;; followed by the elements from l2

(append '(A B) '(C D))  =>  (A B C D)

(length ls)     ;; The length of the list

(length nil)  =>  nil
(length '(A B C))  =>  3


### Conditionals

(cond (p1 e1) ... (pn en))  ;; Evaluates each pi in order until it finds
;; a true guard.  It then evaluates the
;; expression for that guard:

(cond ((eq 0 1) 2) (t 3))  =>  3
(cond ((eq 0 0) 2) (t 3))  =>  2

(if p e1 e2)                ;; More readable syntax for a cond defining
;; the usual "if-then-else".  Use cond if you
;; have more than two conditions to test.

(if (eq 0 1) 2 3)  =>  3
(if (eq 0 0) 2 3)  =>  2


### Function definitions

(defun f ls body)          ;; Defines a function named f, with arguments ls

(defun fact (x)
(cond ((eq x 0) 1)
(t (fact (- x 1)))))

(defun mult(x y) (* x y))

(lambda ls body)           ;; Anonymous function expression

((lambda (x) (* x x)) 3)  =>  9


### Higher-order Operations

(mapcar #'f l)    ;; Map the function f over the elements of l, creating
;; a new list.

(mapcar #'atom '(A (2 3) B))  =>  (t nil t)
(mapcar #'(lambda (x) (+ x 2)) '(1 3))  =>  (3 5)

;; The #' in front of a lambda or function name
;; extracts the "functional object" assocated
;; with that function or lambda expression.  The
;; functional object for a function "f" records
;; the number of arguments expected by f, the
;; code for the body of f, etc.

(apply #'f (e1 ... en))   ;; Equivalent to (f e1 ... en)

(apply #'* '(2 2 3))  =>  12
(apply #'fact '(1 2 3 4))  =>  (1 2 6 24)

(funcall #'f e1 ... en)   ;; Equivalent to (f e1 ... en)

(funcall #'* 2 2 3)  =>  12
(funcall #'fact 1 2 3 4)  =>  (1 2 6 24)


For all of these higher-order operations, note that you do not need #' in front of a parameter name that stores a function you have passed into a function. You only need #' when you refer directly to the symbol for a function definition:

        (defun reverse-map (f l)
(mapcar f (reverse l)))

(reverse-map #'- '(1 2 3))       =>   (-3 -2 -1)


### Impure Features

Here for completeness only. You should not use these in your programs unless explicetly told to do so.

(defvar ls '(a b c))       ;; declares variable ls with given value
(rplaca ls x)              ;; updates ls to be '(x b c)
(rplacd ls (x))            ;; updates ls to be '(a x)