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 (or procedures that manipulate procedures) In functional programming (hence, in Racket) procedures have a first class status: Can be a value of a variable Pass procedures as arguments Return procedures as values Create them at runtime Can be included in data structures 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))))) (define cube (lambda (x) (* x x x)))

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) and add1 is (lambda (x) (+ 1 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 (λ (x) x)) (define add1 (λ (x) (+ x 1))) (define pi-term (λ (x) (/ 1 (* x (+ x 2))))) (define pi-next (λ (x) (+ x 4))) (define sum-integers (λ (a b) (sum id a add1 b))) (define sum-cubes (λ (a b) (sum cube a add1 b))) (define pi-sum (λ (a b) (sum pi-term a pi-next b)))

Advantages Code reuse – Easier maintenance, understanding, debugging… General interface – Expresses a well-defined concept (in this case: sum)

Another Example: Integral (define dx 0.005) (define add-dx (λ (x) (+ x dx))) (define integral (λ (f a b) (* (sum f (+ a (/ dx 2)) add-dx b) dx))) > (integral cube 0 1) > (integral cube 0 1)

More Abstraction: 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 (λ (operation start a b) (if (> a b) start (operation a (sequence-operation operation start (+ a 1) b)))))

Example of Sequence Operations > (sequence-operation * 1 3 5) 60 > (sequence-operation ) 27 > (sequence-operation ) 4 > (sequence-operation expt 1 2 4) > (expt 2 (expt 3 4))

Anonymous Procedures From Greek: ἀνωνυμία, anonymia, meaning "without a name" or "namelessness"

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

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