Download presentation
Presentation is loading. Please wait.
1
PPL Lecture Notes: Chapter 3 High-Order Procedures Revisited
2
Remember let ? (define f (lambda ( x y) (let ((a (+ 1 (* x y))) (b (- 1 y))) (+ (* x (square a)) (* y b) (* a b))))) (define f (lambda (x y) ((lambda (a b) (+ (* x (square a)) (* y b) (* a b))) (+ 1 (* x y)) (- 1 y)) )) We can use LET for defining local functions.
3
applicative-eval[ (f 3 1) ] ==>
applicative-eval[ (f 3 1) ] ==>* Substitute: <body of f>○{x = 3, y = 1} ==> applicative-eval[ ((lambda (a b) (+ (* 3 (square a)) (* 1 b) (* a b))) (+ 1 (* 3 1)) (- 1 1)) ] ==>* applicative-eval[ (+ (* 3 16) (* 1 0) (* 4 0)) ] ==> 48
![applicative-eval[ (f 3 1) ] ==>](http://slideplayer.com./slide/13340262/80/images/3/applicative-eval%5B+%28f+3+1%29+%5D+%3D%3D%3E.jpg "applicative-eval[ (f 3 1) ] ==>* Substitute: <body of f>○{x = 3, y = 1} ==> applicative-eval[ ((lambda (a b) (+ (* 3 (square a)) (* 1 b) (* a b))) (+ 1 (* 3 1)) (- 1 1)) ] ==>* applicative-eval[ (+ (* 3 16) (* 1 0) (* 4 0)) ] ==> 48")
4
Local Procedures (define f (λ (x y) (let ((f-helper (lambda (a b) (+ (* x (* a a)) (* y b) (* a b))) ) ) (f-helper (+ 1 (* x y)) (- 1 y))))) We can use LET for defining local functions.
5
applicative-eval[ (f 3 1) ] ==> applicative-eval[ f ] ==> <proc (x y) (let ...)> applicative-eval[ 3 ] ==> 3 applicative-eval[ 1 ] ==> 1 Substitute: <body of f>○{x = 3, y = 1} ==> applicative-eval[ ( (lambda (f-helper) (f-helper (+ 1 (* 3 1)) (- 1 1))) (lambda (a b) (+ (* 3 (square a)) (* 1 b) (* a b))) ) ] ==>* applicative-eval[ ( <proc (a b)(+ (* 3 (square a)) (* a b)) > (+ 1 (* 3 1)) (- 1 1)) ] ==>* applicative-eval[ (+ (* 3 16) (* 1 0) (* 4 0)) ] ==>* 48
![applicative-eval[ (f 3 1) ] ==> applicative-eval[ f ] ==> <proc (x y) (let ...)> applicative-eval[ 3 ] ==> 3 applicative-eval[ 1 ] ==> 1 Substitute: <body of f>○{x = 3, y = 1} ==> applicative-eval[ ( (lambda (f-helper) (f-helper (+ 1 (* 3 1)) (- 1 1))) (lambda (a b) (+ (* 3 (square a)) (* 1 b) (* a b))) ) ] ==>* applicative-eval[ ( <proc (a b)(+ (* 3 (square a)) (* a b)) > (+ 1 (* 3 1)) (- 1 1)) ] ==>* applicative-eval[ (+ (* 3 16) (* 1 0) (* 4 0)) ] ==>* 48](http://slideplayer.com./slide/13340262/80/images/5/applicative-eval%5B+%28f+3+1%29+%5D+%3D%3D%3E+applicative-eval%5B+f+%5D+%3D%3D%3E+%3Cproc+%28x+y%29+%28let+...%29%3E+applicative-eval%5B+3+%5D+%3D%3D%3E+3+applicative-eval%5B+1+%5D+%3D%3D%3E+1+Substitute%3A+%3Cbody+of+f%3E%E2%97%8B%7Bx+%3D+3%2C+y+%3D+1%7D+%3D%3D%3E+applicative-eval%5B+%28+%28lambda+%28f-helper%29+%28f-helper+%28%2B+1+%28%2A+3+1%29%29+%28-+1+1%29%29%29+%28lambda+%28a+b%29+%28%2B+%28%2A+3+%28square+a%29%29+%28%2A+1+b%29+%28%2A+a+b%29%29%29+%29+%5D+%3D%3D%3E%2A+applicative-eval%5B+%28+%3Cproc+%28a+b%29%28%2B+%28%2A+3+%28square+a%29%29+%28%2A+a+b%29%29+%3E+%28%2B+1+%28%2A+3+1%29%29+%28-+1+1%29%29+%5D+%3D%3D%3E%2A+applicative-eval%5B+%28%2B+%28%2A+3+16%29+%28%2A+1+0%29+%28%2A+4+0%29%29+%5D+%3D%3D%3E%2A+48.jpg "applicative-eval[ (f 3 1) ] ==> applicative-eval[ f ] ==> <proc (x y) (let ...)> applicative-eval[ 3 ] ==> 3 applicative-eval[ 1 ] ==> 1 Substitute: <body of f>○{x = 3, y = 1} ==> applicative-eval[ ( (lambda (f-helper) (f-helper (+ 1 (* 3 1)) (- 1 1))) (lambda (a b) (+ (* 3 (square a)) (* 1 b) (* a b))) ) ] ==>* applicative-eval[ ( <proc (a b)(+ (* 3 (square a)) (* a b)) > (+ 1 (* 3 1)) (- 1 1)) ] ==>* applicative-eval[ (+ (* 3 16) (* 1 0) (* 4 0)) ] ==>* 48")
6
LET and Recursive Procedures
(define fact (λ (n) (let ((iter (lambda (prod c) (if (> c n) prod (iter (* c prod) (+ c 1)))) )) (iter 1 1))))
7
(define fact (λ (n) (let ((iter (λ (prod c) (if (> c n) prod (iter (* c prod) (+ c 1)))))) (iter 1 1)))) (define fact (λ (n) ( (λ (iter) (iter 1 1)) (λ (prod c) (if (> c n) prod (iter (* c prod) (+ c 1)))))))
8
LET and Recursive Procedures
(define fact (λ (n1) (let ((iter2 (lambda (prod3 c3) (if (> c3 n1) prod3 (iter (* c3 prod3) (+ c3 1)))) )) (iter2 1 1))))
9
LETREC “For local recursive functions there is a special operator letrec, similar to let, and used only for local procedure (function) definitions. It’s syntax is the same as that of let. But, the scope of the local procedure declarations includes all of the initialization procedures!”
10
LETREC (define fact (λ (n) (letrec ((iter (lambda (prod c) (if (> c n) prod (iter (* c prod) (+ c 1)))) )) (iter 1 1))))
11
Usage Agreement let: non-procedure locals letrec: procedural locals
The substitution model does not account for local recursive procedures
12
The Sequence Interface
OOP abstracts data. FP is better: abstracts behavior: sequence oprtations Java 8 new feature is sequence operations… Scheme had it for years!
13
What is Sequence Interface?
ADT for lists In other words: a barrier between clients running sequence applications and their implementations Abstracts-away element by element manipulation
14
Map Applies a procedure to all elements of a list. Returns a list as a result ;Signature: map(proc,sequence) ;Purpose: Apply ’proc’ to all ’sequence’. ;Type: [[T1 -> T2]*LIST(T1) -> LIST(T2)] ;Examples: ;(map abs (list )) ; ==> ( ) ;(map (lambda (x) (* x x)) (list )) ; ==> ( ) ;Post-condition: For all i=1..length(sequence): resulti = proc(sequencei)
15
Map in Java? A little better: mySequence.map((lambda (i) (sysout i)))
List<Integer> mySequence = new LinkedList<> {1,2,3,4}; mySequence.map((lambda (i) (sysout i))) Perfect!
16
Map Example: scale-list
Scaling list of numbers by a factor ;Signature: scale-list(items,factor) ;Purpose: Scaling elements of a number list by a factor. ;Type: [LIST(Number)*Number -> LIST(Number)] > (scale-list (list ) 10) ( )
17
Implementation of scale-list
No Map Map (define scale-list (lambda (items factor) (if (empty? items) empty (cons (* (car items) factor) (scale-list (cdr items) factor))))) (define scale-list (lambda (items factor) (map (lambda (x) (* x factor)) items))
18
Map Example: scale-tree
Mapping over hierarchical lists >(scale-tree (list 1 (list 2 (list 3 4) 5) (list 6 7)) 10) (10 (20 (30 40) 50) (60 70))
19
Implementation of scale-tree
No Map Map (define scale-tree (lambda (tree factor) (cond [(empty? tree) empty] [(not (list? tree)) (* tree factor)] [else (cons (scale-tree (car tree) factor) (cdr tree) factor))]))) (define scale-tree (lambda (tree factor) (map (lambda (sub-tree) (if (list? sub-tree) (scale-tree sub-tree factor) (* factor))) tree)))
20
Map in Java List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7); //Old way: for(Integer n: list) { System.out.println(n); } //New way: list.forEach(n -> System.out.println(n)); //Scheme (map list (lambda(n) (display n))
21
Implementation of Map ;Signature: map(proc,items) ;Purpose: Apply ’proc’ to all ’items’. ;Type: [[T1 -> T2]*LIST(T1) -> LIST(T2)] (define map (lambda (proc items) (if (null? items) (list) (cons (proc (car items)) (map proc (cdr items))))))
22
A More General Map So far, the procedure can get only a single parameter: an item in the list Map in Scheme is more general: n-ary procedure and n lists (with same length) Example: > (map + (list 1 2 3) (list ) (list )) ( )
23
Filter Homogenous List
Signature: filter(predicate, sequence) Purpose: return a list of all sequence elements that satisfy the predicate Type: [[T-> Boolean]*LIST(T) -> LIST(T)] Example: (filter odd? (list )) ==> (1 3 5) Post-condition: result = sequence - {el|el∈sequence and not(predicate(el))}``
24
Accumulate Procedure Application
Signature: accumulate(op,initial,sequence) Purpose: Accumulate by ’op’ all sequence elements, starting (ending) with ’initial’ Type: [[T1*T2 -> T2]*T2*LIST(T1) -> T2] Examples: (accumulate + 0 (list )) ==> 15 (accumulate * 1 (list )) ==> 120
25
Interval Enumeration Signature: enumerate-interval(low, high) Purpose: List all integers within an interval: Type: [Number*Number -> LIST(Number)] Example: (enumerate-interval 2 7) ==> ( ) Pre-condition: high > low Post-condition: result = (low low high)
26
Enumerate Tree Signature: enumerate-tree(tree) Purpose: List all leaves of a number tree Type: [LIST union T -> LIST(Number)] Example: (enumerate-tree (list 1 (list 2 (list 3 4)) 5)) ==> ( ) Post-condition: result = flatten(tree)
27
Sum-odd-squares ; Signature: sum-odd-squares(tree) ; Purpose: return the sum of all odd square leaves ; Type: [LIST -> Number] ; tree leaves ---> ; filter: odd? ---> ; map: square ---> ; accumulate: +, 0. (define sum-odd-squares (lambda (tree) (accumulate + 0 (map square (filter odd? (enumerate-tree tree))))))
28
Even Fibonacci Numbers
Without sequence operations: With sequence operations: (define even-fibs (lambda (n) (letrec ((next (lambda(k) (if (> k n) (list) (let ((f (fib k))) (if (even? f) (cons f (next (+ k 1))) (next (+ k 1)))))))) (next 0)))) (define even-fibs (lambda (n) (accumulate cons (list) (filter even? (map fib (enumerate-interval 0 n))))))
29
Filter implementation
;; Signature: filter(predicate, sequence) ;; Purpose: return a list of all sequence elements that satisfy the predicate ;; Type: [[T-> Boolean]*LIST(T) -> LIST(T)] (define filter (lambda (predicate sequence) (cond ((empty? sequence) sequence) ((predicate (car sequence)) (cons (car sequence) (filter predicate (cdr sequence)))) (else (filter predicate (cdr sequence))))))
30
Accumulate Implementation
;; Signature: accumulate(op,initial,sequence) ;; Purpose: Accumulate by ’op’ all sequence elements, starting (ending) ;; with ’initial’ ;; Type: [[T1*T2 -> T2]*T2*LIST(T1) -> T2] (define accumulate (lambda (op initial sequence) (if (null? sequence) initial (op (car sequence) (accumulate op initial (cdr sequence))))))
31
Enumerate-interval Implementation
;; Signature: enumerate-interval(low, high) ;; Purpose: List all integers within an interval: ;; Type: [Number*Number -> LIST(Number)] (define enumerate-interval (lambda (low high) (if (> low high) (list) (cons low (enumerate-interval (+ low 1) high)))))
32
Enumerate-Tree Implementation
;; Signature: enumerate-tree(tree) ;; Purpose: List all leaves of a number tree ;; Type: [LIST union T -> LIST(Number)] (define enumerate-tree (lambda (tree) (cond ((null? tree) (tree)) ((not (list? tree)) (list tree)) (else (append (enumerate-tree (car tree)) (enumerate-tree (cdr tree)))))))
33
Haskell Curry
34
Partial Evaluation using Function Currying
Technique for turning a function with n parameters to n functions with a single parameter Good for partial evaluation
35
Currying ;Type: [Number*Number -> Number] (define add (λ (x y) (+ x y))) ;Type: [Number -> [Number -> Number]] (define c-add (λ (x) (λ (y) (add x y)))) (define add3 (c-add 3)) (add3 4) 7
36
Currying ; Signature: c-sum(term) ; Type: ; [[Number -> Number] -> ; [[Number -> number] -> ; [Number*Number ->Number]]] (define c-sum (lambda (term) (lambda (next) (lambda (a b) (sum term a next b)))))
37
Naïve and non-Naïve Currying
(define add-fib (lambda (x y) (+ (fib x) y))) (define c-add-fib (lambda (x) (lambda (y) (+ (fib x) y)))) (let ((fib-x (fib x))) (+ fib-x y)))))
38
Naïve and non-Naïve Currying
(define c-expt (λ (b) (λ (e) (if (= e 0) 1 (* b ((c-expt b) (- e 1))))))) (define c-expt (lambda (b) (letrec ([helper (λ (e) (if (= e 0) 1 (* b (helper (- e 1)))))]) helper)))
39
Curried Map Delayed List Naïve Version:
;Signature: c-map-proc(proc) ;Purpose: Create a delayed map for ’proc’. ;Type: [[T1 -> T2] -> [LIST(T1) -> LIST(T2)]] (define c-map-proc (lambda (proc) (lambda (lst) (if (empty? lst) lst (cons (proc (car lst)) ((c-map-proc proc) (cdr lst)))))))
40
Curried Map – delay the list
(define c-map-proc (lambda (proc) (letrec ((iter (lambda (lst) (if (empty? lst) lst (cons (proc (car lst)) (iter (cdr lst))))))) iter)))
41
Curried Map – delay the proc
;; Signature: c-map-list(lst) ;; Purpose: Create a delayed map for ’lst’. ;; Type: [LIST(T1) -> [[T1 -> T2] -> LIST(T2)]] (define c-map-list (lambda (lst) (if (empty? lst) (lambda (proc) lst) ; c-map-list returns a procedure (let ((mapped-cdr (c-map-list (cdr lst)))) ;Inductive Currying (lambda (proc) (cons (proc (car lst)) (mapped-cdr proc)))))))
42
(c-map-list ‘(1 2)) mapped-cdr (c-map-list ‘(2)) (c-map-list ‘()) (λ (p) l) (λ (p) (cons (p 2) ((λ (p) l) p)))) (p 1) ((λ (p) ((λ (p) l) p)))) p) (define c-map-list (λ (l) (if (null? l) (λ (proc) l) (let ((mapped-cdr (c-map-list (cdr l)))) (λ (proc) (cons (proc (car l)) (mapped-cdr proc)))))))
Similar presentations
