CSCI 431: Functional Programming Languages

LISP

LISP is a very old language, ref. John McCarthy 1960
It is still the standard for work in AI
Common LISP was created in 1983 by “committee” and is now an ANSI standard
- contains everything you could ever want
Best known related language is Scheme

Interacting with LISP

LISP’s top level is called the Read-Eval-Print loop:
- Reads a LISP expression from the keyboard
- EVALuates it to determine its value
- PRINTs it to the screen
Examples:
```
5
```
LISP returns 5. But now if you type
```
foo
```
LISP returns:
```
Error: The variable FOO is unbound
Error signalled by EVAL
```
Now if you type
```
(+ 1 2)
```
LISP returns:
```
3
```

LISP Expressions

To understand LISP you need to know:
- what kind of expressions LISP understands
- What the evaluation rules are
Everything in LISP (data and programs) is expressed in terms of symbolic expressions, s-expressions
s-expressions come in 2 basic types
- atoms
- lists

Atoms and lists

Atoms are primative data objects; there are many different kinds
- numbers 1 1.3 1/3
- strings and characters: “foo” #\f
- symbols: foo
- many others
Lists are the most important data structure. They consist of 0 or more s-expr’s enclosed in parentheses:
- (a list) (a list containing (a list)) ()
- (((((lots of irritating parentheses!)))))

Evaluation rules for atoms

Most atoms are constants and evaluate to themselves:
```
5
```
LISP returns 5. If you type
```
“foo”
```
LISP returns “foo”
Symbols are variables and evaluate to their values:
```
foo
```
LISP returns:
```
Error: the variable FOO is unbound
```

Evaluation rules for lists

LISP expressions are of the following form:

open-paren operator arguments close-paren
(           +       1       2 )

Extra spaces are ignored, so this expression has exactly the same effect as a more compact spacing:
```
(+ 1 2)
```
The number of arguments depends on the operator. Each argument can itself be a LISP expression.
```
(+ (* 2 3) (- 5 2))
```
Not all operators are just single characters. In general, they are sequences of characters and sometimes numbers and some punctuation.
- Examples:
```
(absolute-value 4)
(list 1 2 3)
(doctor)
```
Some expressions have no arguments.
```
()
```
This expression is also written as NIL which also means false.

Variables

A LISP variable is just a sequence of characters. It can be only a single or it can be a long sequence of characters including numbers and punctuation:
```
x
l (note that this is different from the number 1)
list
a-real-long-variable
var5
```
You cannot use commas or quotation marks in variables. And a variable can't be all numbers, because then LISP will think that it is a number.
Note:In fact it can't be anything that could be taken for a number. So the following are numbers, not symbols:
```
2.3 -3 -3.2 3e4
```
The 3e4 is the way that LISP represents scientific notation, so that is 3 times ten to the fourth power. There are other, more obscure number representations. The best way to find out if something is a number. If when you type it in you get a number back, it is a number. If you get an unbound variable error, it is a variable.)
The function setf binds (assigns) a value to a variable.
```
(setq x 5)
```
LISP returns 5. But now if you type
```
x
```
LISP returns 5 also.

More on Variables

The idea is that you have bound the variable x to the number 5.
There are various ways to bind variables to values. But once x is bound to a value, it can be used in expressions.
```
(+ x 3)
```
and get 8
If you type a variable that you haven't given a value with setq or in some other way, you will get an error.
A variable is called a symbol in LISP.

The following are all ways to assign the value 5 to y:

(setq y 5)
(setq y (1+ 4))
(setq y x)    this assumes that x has been bound to 5 beforehand
(setq y (/ (+ x 5) 2))

If you give setq a first argument that is not a variable, LISP will signal an error.

LISP environment

So the same expression can have a different value depending on when it is evaluated.
We refer to the LISP environment as the record of things like the bindings of variables that can change depending on what you do in LISP. We say that the binding of a variable depends on the environment. And a small number of operators, like setq, modify the environment.
Variables bound to values using setq have global scope. We can define local variables using let construct.

Let and Local Bindings

One of the operators that sets up a local binding is let.
```
(let ((a 2)) (+ a 1))
```
The initial operator is the symbol let. The first argument is a sequence of pairs of variables and values. The next argument of the let expression is itself a LISP expression, in this case the expression (+ a 1), this expression is called the body of the let expression.
In the case of a let form, the first thing that happens is that each variable in the sequence of variables is bound to the value it is associated with. These bindings take place in what is called a local environment, because the bindings are in effect only inside the evaluation of the let form.
The value of the let expression is the result of evaluating what is called the body of the let.

Consider the following sequence of expressions:

(setq a 1)
(+ a 1)
(let ((a 2)) (+ a 1))
(+ a 1)

Within the body of the let expression, a is bound to 2. So the value of the let expression is 3. Outside of the let expression, (+ a 1) evaluates to 2 because the global binding for a is 1.
When you are trying to figure out what value a particular expression has, you must know what the environment will be when it is evaluated.
More examples:
```
(let ((a (+ 3 4))) (- a 2))
```
The value that a is bound to is 7. And so the value of (- a 2) is 5, which is the value of the whole expression.
```
(let ((a 1) (b 2)) (+ a b))
```
Binds a to 1 and b to 2 and then adds them up. So this yields 3.
```
(setq a 1)
(let ((b 2)) (+ a 1))
```
In this case a has a top-level binding to 1 and the let form binds b but not a. So the value that is used for a is the global value namely 1, so the value of the expression is 2.
```
(let ((b 2)) (+ a b))
```
In this case the value of b is obtained from the local environment, and the value of a is obtained from the top-level environment, so the result is 3.
```
(let ((a 1)) 
  (let ((b 2))
     (+ a b)))
```
In this case the outer let form binds a to 1. A let form can contain any LISP expression as its body. So there is nothing wrong with putting another let form in the body. This let form binds b to 2. The body of the inner form is (+ a b).

Predicates

The objects t and nil are returned by a certain class of functions called predicates because they are typically used to determine if some property or relation holds of a LISP object or some sequence of LISP objects.
```
(> 3 2)
```
returns
```
t
```
```
(> 2 3)
```
returns
```
nil
```
We call operators that return t or nil predicates. There is nothing special about LISP predicates, they are just ordinary LISP functions.
Other predicates that are useful with numeric values are these:

Predicate Description
< less than This is the opposite of >
= equals This operator returns t if its two arguments are numerically equal, nil otherwise.
<= less than or equal
>= greater than or equal

Predicate	Description
<	less than This is the opposite of >
=	equals This operator returns `t` if its two arguments are numerically `equal`, `nil` otherwise.
<=	less than or equal
>=	greater than or equal

Defining functions

you can define your own functions using defun:
which means: to evaluate (add-one <s-exp>)
- evaluate <s-exp>
- temporarily bind its value to x
- evaluate the s-exp’s in the function body in order
- return the value of the last one
```
(add-one (add-one 10))
12
```

Examples of user defined predicates

(defun positive (x)
   (>= x 0))

(defun twice (x y)
  (= x (* 2 y)))

When we call twice with these arguments:

(twice 4 2)

The body is

(= x (* 2 y))

Where x is bound to 4 and y is bound to 2. So (* 2 y) returns 4, and x is 4, and = returns t, so twice returns t.

(defun zerop (x) (= x 0))

(defun plusp (x) (> x 0))

(defun minusp (x) (< x 0))

Conditionals

The main use of predicates is to direct the operation of programs. This is done by putting a predicate expression inside what is called a conditional expression. A conditional expression has as its operator one of a small number of LISP conditionals. One of the most basic is called if. Here is an if expression:
```
(if (> 3 2)
    1
    2)
```
The first argument to an if expression is a predicate called the condition part of the if expression. The second argument is called the true consequent, and the third is called the false consequent. The idea is that if the condition part is t, the value of the if is the value of the true consequent, otherwise, the value of the if is the value of the false consequent.
Here is how if could be used inside a function definition. This function returns 0 if its argument is equal to zero, 1 otherwise.
```
(defun zun (arg)
  (if (= arg 0)
      0
      1))
```
So what happends if we call
```
(zun 3)
```
Other Examples:
```
(defun max (x y)
  (if (> x y)
      x
      y))
```
If we call
```
(max 7 7)
```
Then the condition is nil (because 7 is not greater than 7), so the second consequent is evaluated. This returns 7. numbers.
```
(defun distance (a b)
  (if (> a b)
      (- a b)
      (- b a)))
```
As in the case of max, if a and b are equal, then we end up subtracting b from a, but we would have gotten 0 in either case.

Logical Combinations

There are a number of operators in LISP which combine the result of predicates. These correspond to the logical operators.

(not t)
nil

(not nil)
T

(not (= 3 4))
T
(and t t t)
T

(and t nil t)
nil

(and (= 1 1) (= 2 2))
T
(or nil nil nil)
nil

(or t t)
T

(or (= 1 2) (> 5 4))
T

These can be used in conditional statements:

(defun either-zero (x y)
  (or (= x 0) (= y 0)))

(defun in-ten (x)
  (if (and (> x 0) (< x 10))
      x
      5))

A Recursive Function

There are no restrictions, in LISP, as to what function you call when you are inside a function. In particular, it is legal to call the same function that you are defining.

Consider the factorial function:

x! = x (x-1) (x-2) ...

So,

3! = 3*2*1     = 6
5! = 5*4*3*2*1 = 120

A LISP program to compute factorial is:

(defun fact (x)
  (if (= x 0)
      1
      (* x (fact (1- x)))))

The main reason that recursive programs can work is that the local environments created for the variables inside LISP functions are all completely separate.
Another recursive definition is power. The power function raises some number to a power by multiplying the number times itself some number of times.
```
(defun power (x n)
  (if (= n 0)
      1
      (* x (power x (1- n)))))
```
As with factorial, the base case is when one of the arguments is zero, and the value is simple: 1. In the recursive case we compute the power function for the same value of x, and one less than the value of n. The result is then multiplied by x to yield the power function for this value of x and n.

Cond

The cond is the most general conditional in LISP. Where if and when and unless allow only a single test, cond allows any number. Here is an example use of cond:
```
(defun frab (x y)
  (cond ((< x y) (+ x y))
	((= x y) 0)
	(t
         (* x y))))
```
A cond expression begins with the operator cond. This is followed by a sequence of statements each enclosed in parentheses.
Each cond statement begins with a condition and is followed by any number of consequent forms.
So the first statement in this cond is:
```
   ((< x y) (+ x y))
```
The condition is (< x y) and the single consequent form is (+ x y).
The way that cond is interpreted is as follows: The interpreter works on the statements in order. As it gets to each statement, the condition part is evaluated. If it returns t, the consequent forms are evaluated, and the value of the last consequent form is the value of the cond. Once the condition part of a statement returns t, and the associated consequents are evaluated, no more statement forms are considered. If no condition part of a statement in a cond returns t, the value of the cond is nil.

Any expression that looks like this:

	(if < test> 
            < true-consequent>
            < false-consequent>)

Could be written like this:

	(cond ((< test> < true-consequent>)
              (t < false-consequent>)))

For example:

	(if (> x y)
            (- x y)
            (- y x))

Could be written:

	(cond ((> x y) (- x y))
	      (t (- y x)))

Making Lists

The name LISP comes from the words LISt Processing. And the language was created to work with lists. A list in LISP is just a sequence of items. One way to create a list is with the function list.
If you type
```
(setq list-1 (list 1 2 3))
```
LISP returns
```
(1 2 3)
```
What is printed as (1 2 3) is a list. It is the main kind of data-structure used in LISP.
This is not the same as a LISP expression, even though both have parentheses. A LISP expression must always begin with a LISP operator, either a primitive one that is defined in the language, or one that you define -- and the number 1 is not a function (and you can't define it to be a function either).
A list is what is called a LISP object -- it is something that programs written in the language can manipulate.
The function list takes any number of arguments and returns a list with the arguments given.
```
(setq list-2 (list (+ 1 2) (- 5 3) (* 2 5) 7))
(3 2 10 7)
```

Getting Inside Lists

There are a number of functions whose job it is to manipulate lists. The function first returns the first element of a list:
```
(first list-1)
1
```
The function second returns the second element of a list:
```
(second list-1)
2
```
And the function third:
```
(third list-1)
3
```
These go up to tenth.
The function rest takes a single argument which is a list, and returns a list which the same as the original list, except that it doesn't include the first element:
```
(rest list-1)
(2 3)
```
Calling rest on a list doesn't change the original list. It still contains what it did before:

These list accessing functions can be used in combination:

(first (rest list-1))
2

(rest (rest list-1))
(3)

(rest (rest (rest list-1)))
nil

nil is the way that LISP represents the empty list.
We could have defined the function second this way:
```
(defun second (ls)
  (first (rest ls)))
```
There are alternate names for first and rest:
```
first = car
rest  = cdr
```

List Related Predicates

The predicate listp returns t if its argument is a list:
```
(listp list-1)
t

(listp (rest list-1))
t
```
And nil is considered a list also:
```
(listp nil)
t
```
listp only returns t for lists:
```
(listp 4)
nil

(listp t)
nil
```
Another useful predicate is atom. An atom is anything that is not a list with at least one element. Atoms are the simple elements out of which lists are constructed.
```
(atom 6)
t

(atom t)
t

(atom (list 1 2 3))
nil
```
You could define a function to test if something is a list and is not nil, like this:
```
(defun non-nil-list (x)
  (and (listp x)
       (not (null x))))
```
It turns out that LISP already contains a predicate that does this, it is called consp

Adding Elements to Lists

The function cons adds an element to a list. The name comes from the word construct:
```
(setq list-1 (list 1 2 3))

(setq list-2 (cons 0 list-1))
(0 1 2 3)
```
consing an element on the front of a list doesn't change the original list:
```
list-1
(1 2 3)
```
But the new list has the additional element:
```
list-2
(0 1 2 3)
```
cons takes two arguments, the first is any LISP object, the second must be a list. The second argument can be nil, the empty list, in which case the result is a list of one element:
```
(cons 1 nil)
(1)
```
This is the same result as if you typed:
```
(list 1)
(1)
```
Note that (1) is not the same thing as just the number 1. The list (1) is a list that has one member. The number 1 is just a number.
```
(listp (list 1)) => t
(listp 1)        => nil
```
Another Example:
```
(cons 1 (cons 2 (cons 3 nil)))
(1 2 3)
```

Boxes and Pointer Notation

A useful notation has been established among LISP programmers for thinking about list structure. This notation is especially helpful when you are thinking about programs that modify lists.
The notation is based on the idea that each call to the function cons creates a two-element structure in the memory of the computer called a cons cell. The two elements correspond to the two basic accessors.

Here is how a cons cell is drawn:

-----------------
|       |       | 
| first |  rest |
| (car) | (cdr) |
-----------------

Both the first and the rest of the cons cell can contain values. If the values are atoms, we just write them in the cons cell slots. So the structure we would get by evaluating
```
(setq c-1 (cons 'a nil)) => (a)
```
would be drawn like this:
```
-----------------
|       |       | 
|   a   |  nil  |
|       |       |
-----------------
```
And this makes sense because if you typed
```
(first c-1) => a
(rest c-1)  => nil
```
If the contents of either the first or rest of a cons is list, we draw a pointer from the slot to a picture of its contents. Recall that a simple list has another list in its rest slot. Thus the structure that we get by evaluating:
```
(setq c2 (cons 'w (cons 'x nil))) => (w x)
```
looks like this:
```
----------------
|       |      | 
|   w   |  *   |
|       |  |   |
-----------|---| 
           |                     
           V 
       ----------------
       |       |      | 
       |   x   |  nil |
       |       |      |
       ----------------
```
So here we have two cons cells. The first cons cell has a first which is the symbol w, the rest of that points to another cons cell whose first is the symbol x and whose second is nil.

A three-element list would look like this:

----------------
|       |      | 
|   w   |  *   |
|       |  |   |
-----------|---| 
           |                     
           V 
       ----------------
       |       |      | 
       |   x   |  *   |
       |       |  |   |
       -----------|---| 
		  |                     
		  V 
		 ----------------
		 |       |      | 
		 |   y   |  nil |
		 |       |      |
		 ----------------

This structure corresponds to what you would get by evaluating:

(cons 'w (cons 'x (cons 'y nil)))

Note that this is the same as what you would get by evaluating

(list 'w 'x 'y)

'(w x y)

This is an important pattern to remember -- the backbone of a list consists of one cons cell per element of the list, with the rest slot pointing to the next cons cell, or to nil, if it is the end of the list.

Remember that the first or second or third of a list can also be a list. Such lists are represented in a similar fashion, but with pointers coming out of the first slots of some of the cons cells. For example this list has a list as its first element:

(setq c3 '((a b) c))

That this correspond to what would be constructed by:

(cons (cons 'a (cons 'b nil)) (cons 'c nil))

And this helps us draw the diagram:

----------------        ----------------
|       |      |        |       |      |  
|   *   |  *----------> |   c   |  nil |          
|   |   |      |        |       |      |
----|----------|        ---------------- 
    |     
    V                     
----------------
|       |      | 
|   a   |  *   |
|       |  |   |
-----------|---| 
	   |                     
	   V 
	  ----------------
	  |       |      | 
	  |   b   |  nil |
	  |       |      |
	  ----------------

Each call to cons creates one cons cell, and the contents of the cons cell are determined by the values given as arguments to cons.

Eql

Eql is a general predicate for telling whether two objects are the same. If two objects are of different kinds, for example a number and a symbol, they can't be eql. If two objects are of the same kind, then there are specific rules corresponding to that kind of object to tell if it is eql. For numbers, they have to be numerically equal, so eql is the same as =. For symbols they have to have the same sequence of letters. And only one thing is eql to nil, namely nil itself.
For lists, a list is only eql to itself. Each time you call list or cons or even quote, a new list is created, even though it might look the same as another list. So:
```
(setq list-1 '(a b c))
(setq list-2 '(a b c))

(eql list-1 list-2)
nil
```
Even though both of them look the same: (a b c).
But a list is eql to itself:
```
(eql list-1 list-1)
t

(eql list-2 list-2)
t
```

Equal

The predicate equal is used to test if two lists have the same elements in the same order. Here a possible definition:

(defun equal-1 (a b) 
  (cond ((eql a b) t)
        ((atom a) nil)
        ((atom b) nil)
        ((eql (first a) (first b))
         (equal-1 (rest a) (rest b)))))

Notice first that this function will work on things besides lists. If it is given something other than a list, it just checks to see if they are eql. Because if they aren't eql and they aren't lists, then either (atom a) or (atom b) will return t, and so the cond form will exit with nil.
And if a and b get bound to the same list, then clearly a list is equal to itself, so it just returns t.
If a and b aren't eql, and neither are atoms (and hence both are lists), we enter the last statement of the cond. The test part of that statement checks to see if the first elements of the two lists are the same. If not -- if they aren't eql -- the cond just returns nil, and this is right, because the lists have a different element at the front and so there is no way they can have the same elements in the same order.
If the first elements are eql, then the function is called recursively on both lists. So the idea is that two lists are equal if their first elements are eql, and their rests are equal. And since eventually, if you repeatedly take the rest of a list, you will get down to nil, which is an atom, the recursion is well-defined.
Now the function as defined only works for lists whose elements are not lists. But since lists can have lists inside them, we would like a more general equal function such that we can test:
```
(equal '((a b) (c) d) '((a b) (c) d))
```
And have it return t.
What we need to do is, if the elements are themselves lists, to call equal on them. This change is easy to make. Since equal-1 does an eql check on its arguments if they aren't lists, we can just use the function we are defining to compare the elements:
```
(defun equal (a b) 
  (cond ((eql a b) t)
        ((atom a) nil)
        ((atom b) nil)
        ((equal (first a) (first b))
         (equal (rest a) (rest b)))))
```
Now we have two recursive calls to the function equal. One of them is used on each of the elements of the lists. The other is used on the rests of the lists. Both of these are good recursions because, in the first place, eventually, when calling first, we will get an element which is not a list, and, in the second place, we will eventually reach the end of the list.