CS 334 Lisp FAQ

Table Of Contents

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)