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

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

3. 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)))))
מטרת הפונ' היא לסכום המס' בתחום [a,b]

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

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

6. Same Pattern
(define <name> (lambda (a b) (if (> a b) 0 (+ (<term> a) (<name> (<next> a) b)))))
יש לנו תבנית החוזרת על עצמה.

7. Abstraction
;Signature: sum(term,a,next,b) ;Purpose: to compute the sum of terms, defined by <term> ;in predefined gaps, defined by <next>, 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)))))

8. Using the Abstracted Form
(define sum-integers (λ (a b) (sum id a add1 b))) (define sum-cubes (sum cube a add1 b))) (define pi-sum (sum pi-term a pi-next b)))
(define id (λ (x) x)) (define add1 (+ x 1))) (define pi-term (/ 1 (* x (+ x 2))))) (define pi-next (+ x 4)))

9. Advantages Discussion: are there any? Code reuse General interface
Easier maintenance, understanding, debugging…
General interface
Expresses a well-defined concept (in this case: sum)

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

11. 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 (+ a 1) b)))))
גם פעולת החיבור והאיבר הניטרלי הם עכשיו פרמטרים.

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

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

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

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

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

17. Scope and Binding
(lambda (f a b dx) (* (sum f (+ a (/ dx 2.0)) (lambda (x) (+ x dx)) b) dx))
המשתנים המוגדרים הם f a b dx. הסקופ שלהם הוא כל הלאמבדה.
המופעים של + * \ הם מופעים חופשיים.

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

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

20. Local Variables

21. Local Variables
(define f (lambda (x y) ((lambda (a b) (+ (* x (square a)) (* y b) (* a b))) (+ 1 (* x y)) (- 1 y)) ))
A ו-B מתנהגים כמו משתנים מקומיים: הערך שלהם מחושב פעם אחת בלבד, והסקופ שלהם הוא מקומי.
שימו לב כי אי אפשר להגדיר את f_helper בסביבה הגלובלית בגלל שהוא צריך להכיר את x ו-y.

22. Let
(define f (lambda ( x y) (let ((a (+ 1 (* x y))) (b (- 1 y))) (+ (* x (square a)) (* y b) (* a b)))))
מאקרו, או סוכר סינטקטי, ההופך ל-lambda אנונימית.

23. Let
(let ( (<var1> <exp1>) (<var2> <exp2>) ... (<varn> <expn>) ) <body> )
חוק ההערכה של ביטוי let נובע מביטוי ה-lambda אליו הוא מתורגם:
כל אחד מביטויי ה-exp עובר הערכה
כל אחד מהמשתנים ב-body של ה-let מוחלף בערך המתאים.

24. Let vs. Anonymous Lambda
(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)) ))

25. Notes about Let let provides variables (declaration and scope)
<expi> are in outer scope.
<body> is the scope.
Let variables are the bindings.

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