CSCI 431: Functional Programming Languages

Functional Programming

Expresses everything as pure (side-effect free) functions
What functional programming doesn't have:
- side effects (assignment)
- control flow
What functional programming offers
- referential transparency
- function composition
- higher-order functions
- infinite data

Functional Programming Languages

The design of imperative languages is based directly on the von Neumann architecture.
Effeciency is the primary concern, rather than the suitability of the language for software development.
The design of functional languages is based on mathematical functions. A solid theoretical basis that is also closer to the user, but relatively unconcerned with the architecture of the machines on which it runs.
A mathematical function is a mapping of members of one set, called the domain set, to another set, called the range set.
- Expressed as
  - function name
  - list of parameters
  - mapping expression
  - e.g., cube(x) = x * x * x
The objective of the design of a functional programming language is to mimic mathematical functions to the greatest extent possible.
The process of computation is fundamentally different in a functional programming language than in an imperative language.
In a functional programming language variables are not necessary, as is the case in mathematics.
In a functional programming language the evaluation of a function always produces the same result given the same parameters. This is called referential transparency.

LISP

LISP was the first functional programming language. Orininal LISP was a typeless language (otherwise known as a dynamically typed language).
In LISP, function application and the data all have the same form.
- For example, if the list (A B C) is interperted as data it is a simple list of three atoms, A, B, and C.
- If is interperted as a function application, it means that the function names A is applied to the two parameters, B and C.
In the 1970's a dialect of LISP, designed to be cleaner, more modern and simplier than modern dialects of LISP was introduced. It was called Scheme.

Scheme

Interacting with Scheme

Scheme's top level is called the Read-Eval-Print loop:
- Reads a Scheme expression from the keyboard
- EVALuates it to determine its value
- PRINTs it to the screen
Examples:
```
5
```
Scheme returns 5. But now if you type
```
foo
```
Scheme returns:
```
Unbound variable: foo
```
Now if you type
```
(+ 1 2)
```
Scheme returns:
```
3
```

Scheme Expressions

To understand Scheme you need to know:
- what kind of expressions Scheme understands
- What the evaluation rules are
Everything in Scheme (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 different kinds
- numbers: 1 1.3
- strings: "a string"
- symbols: foo
Lists are the most important data structure. They consist of 0 or more s-exp'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
```
Scheme returns 5. If you type
```
"hello"
```
Scheme returns "hello"
Symbols are variables and evaluate to their values:
```
#t
```
Scheme returns #t
```
foo
```
Scheme returns:
```
Error: the variable FOO is unbound
```

Evaluation rules for lists

Scheme will assume that list structures denote application of functions to their arguments. Function calls 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)
```
Scheme always evaluates the operands and applies the operation to the result.
The number of operands or arguments depends on the operator. Each argument can itself be a Scheme 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:
```
(list 1 2 3)
(eq? a b)
(- 4 3)
```
Some expressions have no arguments.
```
()
```

Stopping Evaluation

QUOTE is a function that takes one parameter; returns the parameter without evaluation
Parameters to a function are evaluated before applying the function; use QUOTE to prevent it when inappropriate
QUOTE can be abbreviated with the apostrophe prefix operator
```
         '(a b)
         (quote (a b))
```

Predicates

The symbols #t and #f 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 Scheme object or some sequence of Scheme objects.
```
(> 3 2)
```
returns
```
#t
```
```
(> 2 3)
```
returns
```
()     which is the way #f is printed
```
We call operators that return #t or #f predicates. There is nothing special about Scheme predicates, they are just ordinary Scheme 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, #f otherwise.
<= less than or equal
>= greater than or equal
By convention, predicates end with a question mark. Examples are: symbol?, number?, string?, null?, positive?, and negative?. There are many more.

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

Defining functions

you can define your own functions using define:
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

(define (positive? x)
   (>= x 0))

(define (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.

(define (zero? x) (= x 0))

(define (plus? x) (> x 0))

(define (minus? 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 Scheme 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.
```
(define (zun arg)
  (if (= arg 0)
      0
      1))
```
So what happends if we call
```
(zun 3)
```
Other Examples:
```
(define (max x y)
  (if (> x y)
      x
      y))
```
If we call
```
(max 7 7)
```
Then the condition is #f (because 7 is not greater than 7), so the second consequent is evaluated. This returns 7. numbers.
```
(define (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 Scheme which combine the result of predicates. These correspond to the logical operators.

(not #t)
()

(not #f)
#t

(not (= 3 4))
#t

(and #t #t #t)
#t

(and #t #f #t)
()

(or #f #f #f)
()

(or #t #t)
#t

These can be used in conditional statements:

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

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

A Recursive Function

Consider the factorial function:

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

So,

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

A Scheme program to compute factorial is:

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

Another recursive definition is power. The power function raises some number to a power by multiplying the number times itself some number of times.
```
(define (power x n)
  (if (= n 0)
      1
      (* x (power x (- n 1)))))
```
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 Scheme. Where if and when and unless allow only a single test, cond allows any number. Here is an example use of cond:
```
(define (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 #f.

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

Like LISP, Scheme was created to work with lists. A list in Scheme is just a sequence of items. One way to create a list is with the function list.
If you type
```
(list 1 2 3)
```
Scheme returns
```
(1 2 3)
```
What is printed as (1 2 3) is a list. It is the main kind of data-structure used in Scheme.
This is not the same as a Scheme expression, even though both have parentheses. A Scheme expression must always begin with a Scheme 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 Scheme 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.
```
(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:
```
(car (list 1 2 3))
1
```
The function cdr 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:
```
(cdr (list 1 2 3))
(2 3)
```
Calling cdr 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:

(car (cdr (list 1 2 3)))
2

(cdr (cdr (list 1 2 3)))
(3)

(cdr (cdr (cdr (list 1 2 3))))
()

() is the way that Scheme represents the empty list.

A List Related Predicates

The predicate list? returns #t if its argument is a list. Let's start by defining a symbol to represent a list using define (we will see more about this later).
```
(define list-1 (list 1 2 3))
(1 2 3)

(list? list-1)
#t

(list? (cdr list-1))
#t
```
And #f is considered a list also:
```
(list? #f)
#t
```
You could define a function to test if something is a list and is not (), like this:
```
(define (is-list? x)
  (and (list? x)
       (not (null? x))))
```

Adding Elements to Lists

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

(define 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 Scheme object, the second must be a list. The second argument can be #f, the empty list, in which case the result is a list of one element:
```
(cons 1 #f)
(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.
```
(list? (list 1)) => #t
(list? 1)        => ()
```
Another Example:
```
(cons 1 (cons 2 (cons 3 #f)))
(1 2 3)
```

Boxes and Pointer Notation

A useful notation has been established among Scheme 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
```
(define c-1 (cons 'a #f)) => (a)
```
would be drawn like this:
```
-----------------
|       |       | 
|   a   |   ()  |
|       |       |
-----------------
```
And this makes sense because if you typed
```
(car c-1) => a
(cdr c-1)  => ()
```
If the contents of either the car or cdr 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 cdr slot. Thus the structure that we get by evaluating:
```
(define c2 (cons 'w (cons 'x ()))) => (w x)
```
looks like this:
```
----------------
|       |      | 
|   w   |  *   |
|       |  |   |
-----------|---| 
           |                     
           V 
       ----------------
       |       |      | 
       |   x   |   () |
       |       |      |
       ----------------
```
So here we have two cons cells. The car cons cell has a car which is the symbol w, the cdr of that points to another cons cell whose car is the symbol x and whose second is ().

A three-element list would look like this:

----------------
|       |      | 
|   w   |  *   |
|       |  |   |
-----------|---| 
           |                     
           V 
       ----------------
       |       |      | 
       |   x   |  *   |
       |       |  |   |
       -----------|---| 
		  |                     
		  V 
		 ----------------
		 |       |      | 
		 |   y   |   () |
		 |       |      |
		 ----------------

This structure corresponds to what you would get by evaluating:

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

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 cdr slot pointing to the next cons cell, or to (), if it is the end of the list.

Remember that the car 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 car slots of some of the cons cells. For example this list has a list as its first element:

(define c3 '((a b) c))

That this correspond to what would be constructed by:

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

And this helps us draw the diagram:

----------------        ----------------
|       |      |        |       |      |  
|   *   |  *----------> |   c   |   () |          
|   |   |      |        |       |      |
----|----------|        ---------------- 
    |     
    V                     
----------------
|       |      | 
|   a   |  *   |
|       |  |   |
-----------|---| 
	   |                     
	   V 
	  ----------------
	  |       |      | 
	  |   b   |   () |
	  |       |      |
	  ----------------

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.

Eq?

Eq? 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 eq?. If two objects are of the same kind, then there are specific rules corresponding to that kind of object to tell if it is eq?. For numbers, they have to be numerically equal, so eq? is the same as =. For symbols they have to have the same sequence of letters. And only one thing is eq? to (), namely () itself.
For lists, a list is only eq? 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:
```
(define list-1 '(a b c))
(define list-2 '(a b c))

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

(eq? list-2 list-2)
#t
```

Equal?

The predicate equal? is used to test if two lists have the same elements in the same order. Let's try to define that predicate. Here a possible definition:

(define (equal-1 a b) 
  (cond ((eq? a b) #t)
        ((not (list? a)) #f)
        ((not (list? b)) #f)
        ((eq? (car a) (car b))
         (equal-1 (cdr a) (cdr 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 eq?. Because if they aren't eq? and they aren't lists, then either not (list? a) or not (list? b) will return #t, and so the cond form will exit with ().
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 eq?, 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 eq? -- the cond just returns (), 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 eq?, then the function is called recursively on both lists. So the idea is that two lists are equal? if their first elements are eq?, and their cdr's are equal?. And since eventually, if you repeatedly take the cdr of a list, you will get down to (), 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 eq? check on its arguments if they aren't lists, we can just use the function we are defining to compare the elements:
```
(define (equal? a b) 
  (cond ((eq? a b) #t)
        ((not (list? a)) #f)
        ((not (list? b)) #f)
        ((equal? (car a) (car b))
         (equal? (cdr a) (cdr 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 cdrs of the lists. Both of these are good recursions because,( in the first place, eventually, when calling car, we will get an element which is not a list, and, in the second place, we will eventually reach the end of the list.
Changing Store in Scheme

Variables
- A Scheme 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 (but it must begin with a character).
```
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 Scheme 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 Scheme 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.)
Scheme environment
- We refer to the Scheme environment as the record of things like the bindings of variables that can change depending on what you do in Scheme. We say that the binding of a variable depends on the environment. And a small number of operators, like define and set! modify the environment.
- Variables bound to values using define have global scope. After they have been defined they can be modified using set!.
```
(define LuckNumber 7)
```
  or
```
(define LuckNumber (read))     assume 7 is entered on the keyboard
```
```
(set! LuckNumber 11)    changes the value of
LuckyNumber to 11
```
- 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 Scheme 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:
```
(define 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.
```
(define 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 Scheme 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).