1 / 27

Programming Languages Tucker and Noonan

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

ha
Download Presentation

Programming Languages Tucker and Noonan

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. Programming LanguagesTucker 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

  2. 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

  3. 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

  4. 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

  5. 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

  6. 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

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

  8. Expressions • Cambridge prefix notation for all Scheme expressions: (f x1 x2 … xn) • E.g., • (+ 2 2) ; evaluates to 4 • (+ (* 5 4) (- 6 2)) ; means 5*4 + (6-2) • (define (Square x) (* x x)) ; defines a function • (define f 120) ; defines a global • Note: Scheme comments begin with ; CSC321: Programming Languages

  9. Expression Evaluation • Three steps: • Replace names of symbols by their current bindings. • Evaluate lists as function calls in Cambridge prefix. • Constants evaluate to themselves. • E.g., x ; evaluates to 5 (+ (* x 4) (- 6 2)) ; evaluates to 24 • ; evaluates to 5 ‘red ; evaluates to ‘red CSC321: Programming Languages

  10. 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

  11. 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) ; gives 0 (cdr evens) ; gives (2 4 6 8) (cons 1 (cdr evens)) ; gives (1 2 4 6 8) (null? ‘()) ; gives #t, or true (equal? 5 ‘(5)) ; gives #f, or false (append ‘(1 3 5) evens) ; gives (1 3 5 0 2 4 6 8) (list ‘(1 3 5) evens) ; gives ((1 3 5) (0 2 4 6 8)) • Note: the last two lists are different! CSC321: Programming Languages

  12. Elementary Values • Numbers • integers • floats • rationals • Symbols • Characters • Functions • Strings • (list? evens) • (symbol? ‘evens) CSC321: Programming Languages

  13. Control Flow • Conditional (if (< x 0) (- 0 x)) ; if-then (if (< x y) x y) ; if-then-else • Case selection (case month ((sep apr jun nov) 30) ((feb) 28) (else 31) ) CSC321: Programming Languages

  14. 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

  15. 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

  16. 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

  17. 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

  18. Example: Symbolic Differentiation • Symbolic Differentiation Rules CSC321: Programming Languages

  19. Scheme Encoding • Uses Cambridge Prefix notation E.g., 2x + 1 is written as (+ (* 2 x) 1) • Function diff incorporates these rules. E.g., (diff ‘x ‘(+ (* 2 x) 1)) should give an answer. • 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

  20. 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

  21. 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

  22. Example: Eight Queens • A backtracking algorithm for which each trial move’s: • Row must not be occupied, • Row and column’s SW diagonal must not be occupied, and • 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

  23. 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

  24. 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

  25. 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

  26. 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

  27. 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

More Related