Download Programming Languages

Programming Languages
Tucker and Noonan
Chapter 14: Functional Programming
14.1 Functions and the Lambda Calculus
14.2 Scheme
14.2.1 Expressions
14.2.2 Expression Evaluation
14.2.3 Lists
14.2.4 Elementary Values
14.2.5 Control Flow
14.2.6 Defining Functions
14.2.7 Let Expressions
14.2.8 Example: Semantics of Clite
14.2.9 Example: Symbolic Differentiation
14.2.10 Example: Eight Queens
CSC321: Programming Languages
14-1
Overview of Functional Languages
• They emerged in the 1960’s with Lisp
• Functional programming mirrors mathematical
functions: domain = input, range = output
• Variables are mathematical symbols: not
associated with memory locations.
• Pure functional programming is state-free: no
assignment
• Referential transparency: a function’s result
depends only upon the values of its parameters.
CSC321: Programming Languages
14-2
Functions and the Lambda Calculus
•
The function Square has R (the reals) as domain and
range.
– Square : R  R
– Square(n) = n2
•
•
A function is total if it is defined for all values of its
domain. Otherwise, it is partial. E.g., Square is total.
A lambda expression is a particular way to define a
function:
LambdaExpression  variable | ( M N) | (  variable . M )
M  LambdaExpression
N  LambdaExpression
•
E.g., (  x . x2 ) represents the Square function.
CSC321: Programming Languages
14-3
Properties of Lambda Expressions
•
In ( x . M), x is bound. Other variables in M are free.
•
A substitution of N for all occurrences of a variable x in M is
written M[x  N]. Examples:
•
A beta reduction (( x . M)N) of the lambda expression ( x . M) is
a substitution of all bound occurrences of x in M by N. E.g.,
•
(( x . x2)5) = 52
CSC321: Programming Languages
14-4
Function Evaluation
•
In pure lambda calculus, expressions like (( x . x2)5)
= 52 are uninterpreted.
•
In a functional language, (( x . x2)5) is interpreted normally (25).
•
Lazy evaluation = delaying argument evaluation in a
function call until the argument is needed.
– Advantage: flexibility
•
Eager evaluation = evaluating arguments at the
beginning of the call.
– Advantage: efficiency
CSC321: Programming Languages
14-5
Status of Functions
• In imperative and OO programming, functions
have different (lower) status than variables.
• In functional programming, functions have same
status as variables; they are first-class entities.
– They can be passed as arguments in a call.
– They can transform other functions.
• A function that operates on other functions is
called a functional form. E.g., we can define
g(f, [x1, x2, … ]) = [f(x1), f(x2), …], so that
g(Square, [2, 3, 5]) = [4, 9, 25]
CSC321: Programming Languages
14-6
Scheme
• A derivative of Lisp
• Our subset:
– omits assignments
– simulates looping via recursion
– simulates blocks via functional composition
• Scheme is Turing complete, but
• Scheme programs have a different flavor
CSC321: Programming Languages
14-7
Expressions
• Cambridge prefix notation for all Scheme
expressions:
(f x1 x2 … xn)
• E.g.,
–
–
–
–
(+ 2 2)
(+ (* 5 4) (- 6 2))
(define (Square x) (* x x))
(define f 120)
; evaluates to 4
; means 5*4 + (6-2)
; defines a function
; defines a global
• Note: Scheme comments begin with ;
CSC321: Programming Languages
14-8
Expression Evaluation
• Three steps:
1.Replace names of symbols by their current bindings.
2.Evaluate lists as function calls in Cambridge prefix.
3.Constants evaluate to themselves.
• E.g.,
x
(+ (* x 4) (- 6 2))
5
‘red
; evaluates to 5
; evaluates to 24
; evaluates to 5
; evaluates to ‘red
CSC321: Programming Languages
14-9
Lists
• A list is a series of expressions enclosed in
parentheses.
– Lists represent both functions and data.
– The empty list is written ().
– E.g., (0 2 4 6 8) is a list of even numbers. Here’s how
it’s stored:
CSC321: Programming Languages
14-10
List Transforming Functions
• Suppose we define the list evens to be (0 2 4 6
8). I.e., we write (define evens ‘(0 2 4 6 8)).
Then:
(car evens)
(cdr evens)
(cons 1 (cdr evens))
(null? ‘())
(equal? 5 ‘(5))
(append ‘(1 3 5) evens)
(list ‘(1 3 5) evens)
•
; gives 0
; gives (2 4 6 8)
; gives (1 2 4 6 8)
; gives #t, or true
; gives #f, or false
; gives (1 3 5 0 2 4 6 8)
; gives ((1 3 5) (0 2 4 6 8))
Note: the last two lists are different!
CSC321: Programming Languages
14-11
Elementary Values
•
•
•
•
•
•
•
•
Numbers
integers
floats
rationals
Symbols
Characters
Functions
Strings
•
•
(list? evens)
(symbol? ‘evens)
CSC321: Programming Languages
14-12
Control Flow
• Conditional
(if (< x 0) (- 0 x))
(if (< x y) x y)
; if-then
; if-then-else
• Case selection
(case month
((sep apr jun nov) 30)
((feb) 28)
(else 31)
)
CSC321: Programming Languages
14-13
Defining Functions
• (define ( name arguments ) function-body )
• Examples:
(define (min x y) (if (< x y) x y))
(define (abs x) (if (< x 0) (- 0 x) x))
(define (factorial n)
(if (< n 1) 1 (* n (factorial (- n 1)))
))
• Note: be careful to match all parentheses.
CSC321: Programming Languages
14-14
The subst Function
(define (subst y x alist)
(if (null? alist) ‘())
(if (equal? x (car alist))
(cons y (subst y x (cdr alist)))
(cons (car alist) (subst y x (cdr alist)))
)))
E.g., (subst ‘x 2 ‘(1 (2 3) 2))
returns (1 (2 3) x)
CSC321: Programming Languages
14-15
Let Expressions
• Allows simplification of function definitions by
defining intermediate expressions. E.g.,
(define (subst y x alist)
(if (null? alist) ‘()
(let ((head (car alist)) (tail (cdr alist)))
(if (equal? x head)
(cons y (subst y x tail))
(cons head (subst y x tail))
)))
CSC321: Programming Languages
14-16
Functions
as
arguments
F
(define (mapcar fun alist)
(if (null? alist) ‘()
(cons (fun (car alist))
(mapcar fun (cdr alist)))
))
• E.g., if (define (square x) (* x x)) then
(mapcar square ‘(2 3 5 7 9)) returns
(4 9 25 49 81)
CSC321: Programming Languages
14-17
Example: Symbolic Differentiation
• Symbolic Differentiation Rules
d
(c)  0
dx
d
(x)  1
dx
d
du dv
(u  v) 

dx
dx dx
d
du dv
(u  v) 

dx
dx dx
d
dv
du
(uv)  u
v
dx
dx
dx
 du
d
dv 
(u /v)  v
 u /v 2
 dx
dx
dx 
c is a constant
u and v are functions of x
CSC321: Programming Languages
14-18
Scheme Encoding
1. Uses Cambridge Prefix notation
E.g., 2x + 1 is written as (+ (* 2 x) 1)
2. Function diff incorporates these rules.
E.g., (diff ‘x ‘(+ (* 2 x) 1))
should give an answer.
3. However, no simplification is performed.
E.g. the answer for (diff ‘x ‘(+ (* 2 x) 1)) is
(+ (+ (* 2 1) (* x 0)) 0)
which is equivalent to the simplified answer, 2.
CSC321: Programming Languages
14-19
Scheme Program
(define (diff x expr)
(if (not (list? Expr))
(if (equal? x expr) 1 0)
(let ((u (cadr expr)) (v (caddr expr)))
(case (car expr)
((+) (list ‘+ (diff x u) (diff x v)))
((-) (list ‘- (diff x u) (diff x v)))
((*) (list ‘+ (list ‘* u (diff x v))
(list ‘* v (diff x u))))
((/) (list ‘div (list ‘- (list ‘* v (diff x u))
(list ‘* u (diff x v)))
(list ‘* u v)))
))))
CSC321: Programming Languages
14-20
Trace of the Example
(diff ‘x ‘(+ ‘(* 2 x) 1))
= (list ‘+ (diff ‘x ‘(*2 x)) (diff ‘x 1))
= (list ‘+ (list ‘+ (list ‘* 2 (diff ‘x ‘x))
(list ‘* x (diff ‘x 2)))
(diff ‘x 1))
= (list ‘+ (list ‘+ (list ‘* 2 1) (list ‘* x (diff ‘x 2)))
(diff ‘x 1))
= (list ‘+ (list ‘+ ‘(* 2 1) (list ‘* x (diff ‘x 2)))
(diff ‘x 1))
= (list ‘+ (list ‘+ ‘(* 2 1) (list ‘* x (diff ‘x 2)))
(diff ‘x 1))
= (list ‘+ (list ‘+ ‘(* 2 1) (list ‘* x 0)) 0)
= ‘(+ (+ (* 2 1) (* x 0)) 0)
CSC321: Programming Languages
14-21
Example: Eight Queens
• A backtracking algorithm for
which each trial move’s:
1. Row must not be occupied,
2. Row and column’s SW diagonal
must not be occupied, and
3. Row and column’s SE diagonal
must not be occupied.
• If a trial move fails any of these
tests, the program backtracks
and tries another. The process
continues until each row has a
queen (or until all moves have
been tried).
CSC321: Programming Languages
14-22
Checking for a Valid Move
(define (valid move soln)
(let ((col (length (cons move soln))))
(and (not (member move soln))
(not (member (seDiag move col) (selist soln)))
(not (member (swDiag move col) (swlist soln)))
)))
Note: the and encodes the three rules listed on the previous slide.
CSC321: Programming Languages
14-23
Representing the Developing Solution
• Positions of the queens kept in a list soln whose nth entry
gives the row position of the queen in column n, in reverse
order. E.g., soln = (5 3 1) represents queens in (row,
column) positions (1,1), (3,2), and (5,3); i.e., see previous
slide.
• End of the game occurs when soln has N (= 8) entries:
• (define (done soln) (>= (length soln) N))
• Continuing the game tests hasmore and generates
nextmove: (define (hasmore move) (<= move N))
• (define (nextmove move) (+ move 1)
CSC321: Programming Languages
14-24
Generating Trial Moves
(define (trywh move soln)
(if (and (hasmore move) (not (car soln)))
(let ((atry (tryone move (cdr soln))))
(if (car atry) atry (trywh (nextmove move) soln))
)
soln
))
The try function sets up the first move:
(define (try soln) (trywh 1 (cons #f soln)))
CSC321: Programming Languages
14-25
Trying One Move
(define (tryone move soln)
(let ((xsoln (cons move soln)))
(if (valid move soln)
(if (done xsoln)
(cons #t xsoln)
(try xsoln))
(cons #f soln))
))
•
Note: the #t or #f reveals whether the solution is
complete.
CSC321: Programming Languages
14-26
SW and SE Diagonals
(define (swdiag row col) (+ row col))
(define (sediag row col) (- row col))
(define (swlist alist)
(if (null? Alist) ‘()
(cons (swDiag (car alist) (length alist))
(swlist (cdr alist)))))
(define (selist alist)
(if (null? Alist) ‘()
(cons (seDiag (car alist) (length alist))
(selist (cdr alist)))))
CSC321: Programming Languages
14-27