Lisp is an interpreted language, and as such it has flexibility and power not available to traditional compiled languages such as C, C++, or Java. In Lisp more decisions are made at run-time. In exchange for this flexibility and power, Lisp execution has always been much slower than the traditional languages. Modern Lisp systems have a compiler that improves performance considerably, though not to the level of traditional languages.

• Accessing Lisp:
  • On pandora or other CS Lan clients: Common Lisp is available as gnu clisp, using /usr/local/bin/clisp or just clisp or lisp
  • On the machines in the Linux lab: Two different distributions of Common Lisp are available:
    • gnu lisp: using /usr/local/bin/gcl or just gcl
    • gnu clisp: using /usr/local/bin/clisp or just clisp

• Exiting Lisp:
  • Use (exit) or (quit) (parentheses required -- just exit or quit is an error)
    
  • Ctrl-D works also, but not in error mode.

• Lisp references: Here are some online references, to use along with class notes.
  • Association of Lisp Users: ALU
  • Online tutorials (all three of the tutorials below seem good):
    • Successful Lisp: How to Understand and Use Common Lisp
      
    • Lisp Primer by Colin Allen and Maneesh Dhagat
  • Elementary lisp book by David S. Touretzky: .ps, .pdf [1 MB]. (This is OK, but uses weird diagrams.)
  • Elementary lisp book by David Cooper: .pdf,    local .pdf [404 KB]. (This book is harder.)
  • Guy Steele's lisp reference book: .ps, .pdf [4.6 MB]. (This book is probably too hard.)

• Producing material to hand in: For this and the next recitation you can use any Common Lisp or any other Lisp system you have access to. The following interactive session shows how to use the lisp function dribble to create a log of a Lisp session for printing, so that you can turn in the results of this recitation. You can also use selection and copy from a terminal window to achieve the same result. The material in bold below is what you type.

  % lisp
  > 12
  12
  > (dribble 'file.out)  ; turn on logging
  ;;; Dribble file "FILE.OUT" started
  T
  > (+ 3 4 )
  7
  > (dribble)            ; turn off logging
  ;;; Dribble file "FILE.OUT" finished
  T
  > (quit)
  % cat FILE.OUT
  ;;; Dribble file "FILE.OUT" started
  T
  > (+ 3 4 )
  7
  > (dribble)
  ;;; Dribble file "FILE.OUT" finished
  

• Simple syntax: The Lisp interpreter reads a sequence of S-expressions, which are either atoms (a constant or identifier), or a parenthesized list of S-expressions, separated by blanks when necessary. Notice the recursive form of this definition, showing from the start how important recursion is to Lisp. Lisp S-expressions always return a result, and they also often have side-effects, such as defining or invoking functions.

• Constants: The simplest form of S-expression is a constant, which has itself as value. Lisp is not case-sensitive, so our input to the Lisp interpreter will be in lower-case, and Lisp will change it to upper-case, except for letters inside double quotes.

  > 47              ;;; integer constant
  47
  > "Lisp"          ;;; string constant
  "Lisp"
  > -.34e-2         ;;; float constant
  -0.0034
  > t               ;;; this is true in Lisp
  T
  > nil             ;;; this is false
  NIL
  > ()              ;;; this is also false
  NIL
  > (equal () nil)  ;;; they are equal!
  T
  

• Simple lists: Given a simple list of atoms, Lisp regards the first item as a function, makes a list out of the remaining arguments, and then applies this function to that list of arguments:

  > (+ 8 5)
  13
  > (/ 355 113)
  355/113
  > (/ 355.0 113.0)   ;;; clisp
  3.141593
  > (/ 355.0 113.0)   ;;; gcl
  3.1415929203539825
  

• Evaluating lists: The previous section didn't tell the whole story. When Lisp is given a list, it evaluates the list (using Lisp function eval). Lisp takes the first (top-level) element of the list. It must be an atom that represents a function. Then Lisp evaluates each of the other elements of the list recursively (again using eval). Lisp makes a list of these evaluated elements, and applies the first function to these values:

  > (* (+ (* 5 4) (/ -4 2) ) 37)
  666
  > (+ (* 2 2) (* 3 3) (* 5 5) (* 7 7) (* 11 11)  ;;; continue to next line
      (* 13 13) (* 17 17))   ;;; last ')' completes the S-expression
  666
  

• Giving atoms a value: Some special functions in Lisp do not evaluate all their arguments. One such is setq. It does not evaluate its first argument, which must be an atom, but it does evaluate its second argument. In addition, it gives a value to the atom which is its first argument:

  > (setq x (+ 7 40))
  47
  > (+ 14 x)
  61
  > x
  47
  > y
  Error: The variable Y is unbound.
  

• Stopping evaluation: Sometimes we don't want to evaluate a list or an atom. quote is another Lisp special function that doesn't evaluate its argument, but instead returns it unevaluated. A single quote mark, without the parens, gives a shorthand version of the longer form.

  > (quote (a b c))
  (A B C)
  > '(a b c)
  (A B C)
  > (a b c)
  Error: The function A is undefined.
  

• car and cdr tear lists apart: car returns the first element of a list, and
  cdr returns the remainder of the list with the first element deleted.

  > (car '(a b c))      ;;; first element is a
  A
  > (cdr '(a b c))      ;;; rest of list is (b c)
  (B C)
  > (car (cdr '(a b)))  ;;; cdr gives (b), and car of that is b
  B
  > (car (a b c))       ;;; lisp tries to evaluate (a b c)
  Error: The function A is undefined.
  

• cons puts two lists together: cons assembles a list from its car and cdr.

  > (cons 'a '(b c))
  (A B C)
  > (cons (car '(a b c)) (cdr '(a b c)))
  (A B C)
  

• Mathematics:

  +  -  *  /  1+  gcd  lcm  acos  asin atan  cos  cosh  sin  tan
  abs  ceiling  exp  floor  log  max  min  mod  round  sqrt
  evenp  minusp  oddp  plusp  zerop  =  /=  <  >  <=  >=

• List Functions:

  first (same as car)  second  third  fourth  ...  last  rest (same as cdr)
  caar  cadr  cdar  cddr  ...  append  list

• Other Predicates: (Return t or nil)

  member  atom  listp  null  eq  eql  equal  numberp

• cond is another special function that evaluates its arguments in a sequential way:

  (cond
     (pred1  result1)
     (pred2  result2)
     ...
     (t      default))
  

  Here predi is a predicate. If pred1 is true, the value of the cond is result1, and no more of the cond is evaluated. Otherwise if pred2 is true, the value of the cond is result2, and no more of the cond is evaluated, and so forth. If none of the predicates is true, then the value will be default.

• Discussion and examples.
• Convert to and from internal representation: Conversion program in C.

• defun is another special function that does not evaluate its arguments, but produces the side effect of defining a function:

  (defun  fname (v1 v2 ... vn)
     ;; body of function (sequence of S-expressions)
     ;; value of last one is value returned
                  )
  

• A call to this function has the form:

  (fname arg1 arg2 ... argn)
  

• Above fname is the name of the function, v1 v2 ... vn are the n formal parameters which must be identifiers, arg1 arg2 ... argn are the n actual parameters which can be any S-expressions, which will all be evaluated before the function is applied using the supplied definition.
• Here are initial examples of functions in Lisp: .txt, .pdf, .ps.
• Here is a way you could do early parts of the Lisp recitation more easily: .txt, .pdf, .ps.

• Discussion and examples.

Lisp in C.