PPL Lecture 3 Slides by Yaron Gonen, based on slides by Daniel Deutch and lecture notes by Prof. Mira Balaban

Warm-up Is this recursive or iterative? (define sum (lambda (n) (if (= n 0) 0 (+ (/ 1 (pow 2 n)) (sum (- n 1))))))

The Iterative Version (define sum-iter (lambda (n prod) (if (= n 0) prod (sum-iter (- n 1) (+ prod (/ 1 (pow 2 n)))))))

Today: High-Order Procedures In functional programming (hence, in Scheme) procedures have a first class status: Pass procedures as arguments Create them at runtime Help in creating local-variables 5

Motivation Example: sum-integers ;Signature: sum-integers(a,b) ;Purpose: to compute the sum of integers in the interval [a,b]. ;Type: [Number*Number -> Number] ;Post-conditions: result = a + (a+1) b. ;Example: (sum-integers 1 5) should produce 15 (define sum-integers (lambda (a b) (if (> a b) 0 (+ a (sum-integers (+ a 1) b)))))

Motivation Example: sum-cubes ;Signature: sum-cubes(a,b) ;Purpose: to compute the sum of cubic powers of ;integers in the interval [a,b]. ;Type: [Number*Number -> Number] ;Post-conditions: result = a^3 + (a+1)^ b^3. ;Example: (sum-cubes 1 3) should produce 36 (define sum-cubes (lambda (a b) (if (> a b) 0 (+ (cube a) (sum-cubes (+ a 1) b)))))

Motivation Example: pi-sum (define pi-sum (lambda (a b) (if (> a b) 0 (+ (/ 1 (* a (+ a 2))) (pi-sum (+ a 4) b)))))

Same Pattern (define (lambda (a b) (if (> a b) 0 (+ ( a) ( ( a) b)))))

Abstraction ;Signature: sum(term,a,next,b) ;Purpose: to compute the sum of terms, defined by ;in predefined gaps, defined by, in the interval [a,b]. ;Type: [[Num -> Num] * Num * [Num -> Num] * Num -> Num] ;Post-conditions: result = (term a) + (term (next a)) +... (term n), ;where n = (next (next...(next a))) =< b, ;(next n) > b. ;Example: (sum identity 1 add1 3) should produce 6, ;where ’identity’ is (lambda (x) x) (define sum (lambda (term a next b) (if (> a b) 0 (+ (term a) (sum term (next a) next b)))))

Using the abstracted form (define id (lambda(x) x)) (define add1 (lambda (x) (+ x 1))) (define pi-term (lambda (x) (/ 1 (* x (+ x 2))))) (define pi-next (lambda (x) (+ x 4))) (define sum-integers (lambda (a b) (sum id a add1 b))) (define pi-sum (lambda (a b) (sum pi-term a pi-next b)))

Advantages Code reuse – Easier maintenance, understanding, debugging… General interface – Expresses a well-defined concept – Allows for further abstraction (next slide)

Sequence Operations ;Signature: … ;Type: [[Number*Number -> Number]*Number*Number*Number -> Number] ;… ;Example: (sequence-operation * 1 3 5) is 60 ;Tests: (sequence-operation ) ==> 2 (define sequence-operation (lambda (operation start a b) (if (> a b) start (operation a (sequence-operation operation start (+ a 1) b)))))

Anonymous Procedures λ forms evaluated during computation (no define) Useful in many cases. (define pi-sum (lambda (a b) (sum (lambda (x) (/ 1 (* x (+ x 2)))) a (lambda (x) (+ x 4)) b)))

Anonymous Procedures Disadvantage: careless use may cause the same λ to reevaluate: (define sum-squares-iter (lambda (n sum) (if (= n 0) sum (sum-squares-iter (- n 1) (+ sum ((lambda (x) (* x x)) n))))))

Scope and Binding In a λ form every parameter has – Binding (declaration) – Occurrence – Scope: lexical scoping In nested λ, things are a little tricky. An occurrence without binding is called free define is also declaration. Its scope is universal.

Scope and Binding (lambda (f a b dx) (* (sum f (+ a (/ dx 2.0)) (lambda (x) (+ x dx)) b) dx))

Local Variables Essential programming technique: mostly used for saving repeated computation. Can we use scoping to define local variables? Yes we can!

Local Variables Consider the function: It is useful to define 2 local variables: a = 1+xy b = 1-y

Local Variables

(define f (lambda (x y) ((lambda (a b) (+ (* x (square a)) (* y b) (* a b))) (+ 1 (* x y)) (- 1 y)) ))

Let (define f (lambda ( x y) (let ((a (+ 1 (* x y))) (b (- 1 y))) (+ (* x (square a)) (* y b) (* a b)))))

Let (let ( ( ) ( )... ( ) ) )

Let vs. Anonymous Lambda Let (define f (lambda ( x y) (let ((a (+ 1 (* x y))) (b (- 1 y))) (+ (* x (square a)) (* y b) (* a b))))) Lambda (define f (lambda (x y) ((lambda (a b) (+ (* x (square a)) (* y b) (* a b))) (+ 1 (* x y)) (- 1 y)) ))

Notes about Let let provides variables (declaration and scope) are in outer scope. is the scope. Let variables are the binind.

From Midterm 2008 סמן את כל הבלוקים הלקסיקליים (scopes) בקטע הבא. מהו הערך המוחזר ? (let ((x 2)) (let ( (x 3) (y x) ) ((lambda (x y +) (+ x y)) (- x y) x *)))