ICS 141 Klefstad

Functional Programming Languages

Outline

Introduction

imperative languages are influenced by von Neumann architecture
functional Languages are influenced by mathematical functions
LISP was the first, others have followed
AI and early programming environment research was done in LISP

Mathematical Functions

a function is a mapping from the 'domain set' to the 'range set'
a function definition specifies the domain, range, and the mappin rule
a function is applied to an element of the domain
it yields or returns a member of the range
evaluation is controlled by conditional and recursion
functions have no side effects

Simple Functions

definition
```
(defun square (x) (* x x))
```
application
```
(square 9.0) yields 81.0
```
a Lambda is a literal function
```
((lambda (x) (* x x)) 9.0) yields 81.0
```

Functional Forms

a functional form operates on functions

AKA higher order function

(defun f (x) (+ x 2))
(defun g (x) (* 3 x))

e.g., composition
```
(defun h (x) (f (g x))
```
e.g., construction
```
[f, g, h](4) yields (6, 12, 14)
```
e.g., apply-to-all
```
MAP(g, (4, 6, 10)) yields (12, 18, 30)
```

Fundamentals of Functional Programming Languages

have no variables or assignment operators
functions are applied to their evaluated arguments
formal parameters are bound to evaluated actuals
repetition is done via recursion
functional languages typically have the following form:
- a set of primitive functions
- a set of functional forms
- a function application operation
- a data structure (usually recursive)

LISP

(McCarthy, 1958)
originally developed for doing symbolic differentiation
early lisp, called pure lisp, is a simple, functional language
has dynamic scoping, dynamic typing, dynamic evaluation
has automatic garbage collection
evolved to include imperative language features for efficiency

LISP Data Types

a symbolic expression is either an atom or a list
a list has two components: car and cdr
an atom may be any of the following:
- a number: 1 13.8
- a symbol: factorial address-list
- a string: "Hello There" "This is a string"
car and cdr are both symbolic expressions
nil represents the empty list but is also an atom

lists

proper lists
```
(A B C)
((A) (B) (C))
```
other lists
```
(A B . C)
(A . B)
```

Primitive functions

cons

-> (cons 'a 'b)
(a . b)
-> (cons 'a (cons 'b nil))
(a b)

car
```
-> (car '(a b))
a
```
cdr
```
-> (cdr '(a b))
(b)
```

Variables and quote

set

-> (set 'a '(1 2 3))	;	 expands to (set (quote a) (quote (1 2 3)))
(1 2 3)

setq

-> (setq a '(1 2 3))	;	setq quotes its first argument
(1 2 3)

Number and String evaluation

evaluate to themselves

e.g.,

-> 123
123
-> "Dumb stuff"
"Dumb stuff"

Atom evaluation

evaluate to their value
values are assigned either by setq or parameter binding

e.g.,

-> (setq a '(a b c))
(a b c)
-> a
(a b c)

function call evaluation

evaluate to applying the function to its evaluated arguments

e.g.,

-> (setq a '(1 2 3))
(1 2 3)
-> (car a)
1
-> (cdr a)
(2 3)
-> (cdr '(a b c))
(b c)

Additional Evaluation

EVAL may be called explicitly to allow additional evaluation

-> (setq a '(car a))
(car a)
-> (eval a)
car
-> (eval (car (cdr a)))
(car a)
-> (eval (cons 'car (cons 'a nil)))
car

The Conditional Expression

cond is the conditional selection expression

syntax

(cond
  (cond1	exp-list1)		; called a  cond clause
  (cond2	exp-list2)
  ...
  (condN	exp-listN))

e.g.,

(cond
  ((null l)	nil)
  ((atom l)	(list l))
  ((listp l) (append (flatten (car l)) (flatten (cdr l)))))

User Defined Functions

defun allows a function definition

(defun function_name (formal_parameter_list)
  expression)

e.g.,

(defun fact (n)
  (cond
    ((eq n 0) 1)
    (t (times n (fact (sub1 n))))))

a function call

(function_name actual_parameter_list)
(defun add2 (x) (add x 2))
-> (add2 1)
3
((lambda (x) (add x 2)) 1)
3

e.g.,
```
-> (fact 3)
6
```

Recursion

recursion is the primary method of control in LISP
the general form of a recursive function is a case analysis

e.g.,

(defun f (x)
  (cond
    ((terminal case) (action))
    ((inductive case calls f) (action))))

tail recursion

applies action to every element of a list

(defun f (x)
  (cond
    ((null x) nil)
    (t (g (car x)) (f (cdr x)))))

complete recursion
- break apart the list, apply function to car and cdr
- reassemble the results
```
(defun f (x)
  (cond
    ((atom x) (list x))
    (t (append (f (car x)) (f (cdr x))))))
```

predicates

(null x)
(atom x)
(numberp x)
(symbolp x)
(listp x)
(eq a1 a2)
(equal l1 l2)

logicals
```
(and x y)
(or x y)
(not x)
```

list operations
```
(list x y)
(append x y)
```

arithmetic

(plus 2 3 4)
(minus 4 3)
(times 2 3 4)
(divide 6 3)

input/output

read an expression, return it
```
(read)
```
print an expression, return nil
```
(print x)
```
print a newline, return nil
```
(terpri)
```

environment

load the module
```
module load franz
```
to run the lisp interpreter
```
% scl
```

tracing

-> (trace function)
-> (trace variable)
-> (untrace function)

including a file
```
-> (load "foo.l")
```
exiting the LISP interpreter
```
^D
```

interrupt a running program to allow examining execution state

(break) or ^C
Restart options (Type :C <number>):
  0: Provide a value to store as the definition of EXIT
  1: Retry getting the definition of EXIT
  2: Lisp Top Level
to get back to top level

  :c 2

the LISP compiler

LISP environments typically include a compiler

help

(help* "keyword") ; help related to the keyword
(help 'function)  ; help related to function

Scheme

(Sussman and Steel, 1975)
Scheme is a newer dialect of Lisp
was developed for teaching introductory programming
has static scoping
is simpler than LISP

COMMON LISP

(Steele, 1984)
many dialects of lisp were in use
common lisp is a standard merge of the different dialects
default is static scoping, but dynamic scoping is optional
includes records, arrays, hash tables, etc.
also includes variables, assignment, looping

(Milner et. al. 1990)
statically scoped functional language
syntax is more like Pascal
strongly typed, but allows type inferencing
has exception handling, modules
has enumerated types, arrays, and tuples (records)

allows definition of polymorphic functions

fun length (l) = if null(l) then 0 else 1 + length(next(l));

Miranda

(Turner, 1986)
a cross between ML and Prolog
no variables or assignment operator
uses lazy evaluation - expression is evaluated when value is needed
```
fact 0 = 1
fact n = n * fact (n - 1)
```

guards can be added

fact n = 1, if n = 0
fact n = n * fact (n - 1), if n > 0

has lists

sum [] = 0
sum (a:x) = a + sum x
product [] = 1
product (a:x) = a * product x

can specify list comprehensions

[n * n * n | n <-- [1..]]
factors n = [i | i <-- [1..n div 2]; n mod i = 0]

quick sort in Miranda

sort [] = []
sort (a:x) = sort [b | b <- x; b <= a] ++ [a] ++ sort [b | b < x; b > a]

A Comparison of Functional and Imperative Languages

functional languages are higher-level
allow quicker program construction
however, efficiency suffers on von Neuman machines