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)