CS 540 Lecture Notes: Lisp Overview

University of Wisconsin - Madison

CS 540 Lecture Notes

C. R. Dyer

Lisp Overview

Lisp Characteristics

Designed for symbolic computation. Symbols (atoms) are the basic data type. Symbols are put together to create structures, usually in the form of a symbolic expression, or s-expression
Example application: Natural language processing. Words as symbols, sentences as lists, trees for grammatical structure
Example application: Express a record as a list such as
(cs540 (type cs-course) (instructor dyer) (tas finton so))
Functional language: compute by evaluating nested functional expressions, which each return a value; functions not generally used for "side effects"
Based on the Lambda Calculus by A. Church
Modular
Data and programs look alike. For example, (orange pear banana) is data and (append x y) is a program. Means that programs can create or modify data and then later that data is interpreted (i.e., executed) as code.
Code developed in interpretive mode

Evaluating Expressions

Prompt-Read-Eval-Print loop: Lisp prints a prompt, then read the expression you type, then "evaluates" it, and finally prints the value computed by the expression.

Kinds of expressions and how they are evaluated:

Numbers: evaluate to themselves (so no need to quote numbers)
Strings: evaluate to themselves (so no need to quote strings)
Symbolic atoms: evaluate to the value bound to the atom (so don't quote an atom if you want the value bound to it; quote the atom if you want the atom treated as a constant)
Functional expressions are of the form (fn arg1 arg2 ... argn) and are (normally) evaluated by:
1. get the function definition associated with the atom name that is the first element of the list,
2. evaluate (recursively) each argument, left to right,
3. pass the values of each of the arguments to the function,
4. compute the function, and
5. return the value computed by the function

For example, Evaluating 3 returns 3
Evaluating "Jane Doe" returns "Jane Doe"
Evaluating x returns the value bound to x or "error" if x unbound
Evaluating 'x returns x
Evaluating (+ 1 2) returns 3
Evaluating (+ (* 3 5) 2) returns 17

Basic Data Types

			     |--- string  Ex. "Jane Doe"
			     |
			     |--- number  Ex. 27, 1.44
			     |
		|--- atom ---|--- symbol  Ex. hungry, x
		|
                |
s-expression ---|--- list  Ex. (elem1 elem2 ... elemn)
		|          (+ 2 3)
		|          ((name bud)(age 20)(parents (al peggy)))
		|
		|--- dotted pair   Ex. (age . 20)

Binding is the process of associating a value with a (symbolic) atom, including allocating storage the first time the atom is referenced. Atoms are not declared or typed. The data bound to an atom has a type. All symbols are initially unbound.

Binding is usually done using the setf function:

  (setf x 3)           ;  bind value 3 to symbol x
  (setf family '(al peggy bud))   ; bind the list
				  ; (al peggy bud) to
				  ; the symbol family

A list is an ordered sequence of 0 or more elements surrounded by parentheses. E.g., (a b c) is a list of length 3, (a ((b)) c) is a list of length 3, ((a b) c) is a list of length 2, and () is a list of length 0 called the empty list or NIL.

Operations on List Structures

Because the list structure is the basic one for building data objects, there are a number of access and constructor functions built into Lisp:

Access Functions

Retrieve a part of a given expression

first - return the first element

      (first '(one two three)) --> one
      (first '((one) (two) (three))) --> (one)

rest - return a list containing all but the first element

      (rest '(one two three)) -->  (two three)
      (rest '(one)) --> () or, equivalently, NIL

second, third, ..., nth, last

Constructor Functions

Construct a new s-expression

cons - takes one element and adds it to the front of a given list. If the given list of of length k, then the returned list is of length k+1. Non-destructive.
```
      (cons 'a '(b c)) --> (a b c)
      (cons'(a) '((b c))) --> ((a) (b c))
      (cons 'a nil) --> (a)
      (cons 'a (cons 'b nil)) --> (a b)
      
```

list - constructs a list from a given set of elements.

    (list 'a 'b '(c d)) --> (a b (c d))

quote - Constructs a new constant s-expression from the given argument. Acts like the identity function.

    (quote (a b c)) --> (a b c)
    '(a b c) --> (a b c)
    '(+ 1 2) --> (+ 1 2)
    'orange --> orange

append - construct a list from two given lists.

    (append '(a b) '(c d)) --> (a b c d)

Plus many others...

Predicates

Functions that return true (usually T, but sometimes a non-NIL s-expression) or false (NIL) as their result

atom - test if an s-expression is an atom

    (atom 'a) --> T    T is a special atom indicating "true"
    (atom '(a)) --> NIL   NIL is used here to indicate "false"
			  (not the empty list)

endp - test if a list is empty

    (endp '(a)) --> NIL
    (endp NIL) --> T

equal - test if two s-expressions "look the same when printed," i.e., "structural equality" so that the values are the same expression. Use equal when comparing two lists.
```
    (equal 'a 'a) --> T
    (equal '(a b) '(a b)) --> T
    (equal '(a b) '(a (b))) --> NIL
    
```
eq - test if two atoms are the same or two s-expressions are in the same locations in memory. Hence, the expressions must be identical, not just look the same.
```
    (eq 'a 'a) --> T     atoms are always unique
    (eq '(a) '(a)) --> NIL
    (setf x '(a))
    (setf y x)
    (eq x y) --> T
    
```
eql - test if two atoms, numbers, characters or strings are the same. Numbers, characters and strings may not be associated with any particular memory location, so eq is not appropriate for them. Numbers must be of the same type to satisfy eql. This is the default predicate used in many other functions that do equality testing.
```
    (eql 'a 'a) --> T
    (eql 4 4) --> T
    (setf x (+ 2 2.3))
    (eql 4.3 x) --> T
    
```

= - test if two numbers are the same. The numbers do not have to be the same type to be =.

    (= 4 4.0) --> T
    (= 'a 'a) --> Error: arguments must be of type number

member - test if an s-expression is a top-level member of a list. Uses eql as its default testing predicate.

    (member 'b '(a b c)) --> (b c)
    (member '(a b) '(a b c)) --> NIL
    (member 'b '(a (b) c)) --> NIL
    (member '(a b) '(a (a b) c)) --> NIL
    (member '(a b) '(a (a b) c) :test #'equal) --> ((a b) c)

listp, null, numberp, zerop, and many more

Logical Operators

not, and, or
and and or use lazy evaluation to return a value as soon as the value of the operation is determined during left-to-right evaluation of their arguments.

   (setf lst '(a b c))
   (and (member 'd lst) (member 'b lst)) --> NIL
   (and (member 'a lst) (member 'b lst)) --> (b c)
   (or (member 'a lst) (member 'd lst)) --> (a b c)

Writing Functions

  (defun my-second (lst)
     (first (rest lst)))

lst is the formal parameter which gets a value bound to it when the function is called. The body (a sequence of s-expressions) is evaluated and the result of the last expression evaluated is returned as the value of the function my-second

  (defun insert-second (item lst)
     (cons (first lst)
	   (cons item (rest lst))))

But the above doesn't work if the input list is empty, so change it to:

  (defun insert-second (item lst)
     (if (null lst)
	 (list item)   ;; return a list of length 1 containing item
	 (cons (first lst)
	       (cons item (rest lst)))))

Another example using cond instead of if:

  (defun age-group (person)
     (let ((n (age person)))  ;; age is a function that returns the age of
			      ;; person and then binds it to the local
			      ;; variable n, which is defined for the body
			      ;; of the let
        (cond ((< n 2) 'baby)
	      ((< n 18) 'child)
	      ((< n 120) 'adult)
	      (t 'dead))))

Variables are lexically scoped by default in Lisp. Below is one way of defining functions lexically within the scope of a local variable called stack:

   (let ((stack nil))
      (defun push (item)
	 (setf stack (cons item stack)))

      (defun pop ()
	 (prog1 (first stack)
		(setf stack (rest stack))))

Writing Recursive Functions

The key to writing recursive functions is to define the recursion relation that describes for the general case how a problem can be solved in terms of a simpler problem of the same form plus some computation to solve the original problem from the solution to the simpler problem. The other thing to take care of is when the recursion relation is false; these are the termination, or base, cases that stop the recursion.

Some examples:

Factorial

(defun fact (n)
   (if (= n 1)   ; termination case -- 1! = 1
       1
       (* n (fact (- n 1)))))   ; recursion relation: n! = n * (n-1)!

Another Version of Factorial
Whereas the above version performs the multiplication after returning from the recursive call, the version below does the multiplication before the recursive call and passes the result so far as an argument. This means that the value returned by the recursive call is the value that is also returned by the calling function. Consequently, this version is called "tail recursive."
```
(defun fact (n)
   (fact-aux n 1)

(defun fact-aux (n result)
   (if (= n 1)
       result
       (fact-aux (- n 1) (* n result))))
```

Length

(defun my-length (lst)
;; return the number of top-level elements in a list lst
   (if (endp lst)    ; base case - an empty list has length 0
       0
       (+ 1 (my-length (rest lst)))))   ; recursion relation - a list is
			   	        ; one longer than a list that has its
					; first element removed

For comparison, an iterative version of length can be defined by

(defun my-length (lst)
   (let ((result 0))
      (dolist (elem lst result)
         (setf result (1+ result)))))

(defun my-length (lst &aux (result 0))
   (dolist (elem lst result)
      (setf result (1+ result))))

Count All Atoms at All Levels
```
(defun count-all-elems (expr)
   (cond ((null expr) 0)   ; an empty list has 0 elements in it
         ((atom expr) 1)   ; an atom is exactly 1 element
         (t (+ (count-all-elems (first expr))
               (count-all-elems (rest expr))))))
```
Notice that recursion is used here in two ways: first to recurse across the successive elements of a list (the second recursive call), and second to recurse down through all sub-lists, sub-sub-lists, etc. (the first recursive call).

Equal

(defun my-equal (expr1 expr2)
   (if (or (atom expr1) (atom expr2))
       (eql expr1 expr2)
       (and (my-equal (first expr1) (first expr2))
            (my-equal (rest expr1) (rest expr2)))))