Download PPL

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)^3 + ... + 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 <name>
(lambda (a b)
(if (> a b)
0
(+ (<term> a)
(<name> (<next> a) b)))))
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)
(define sum
(lambda (term a next b)
(if (> a b)
0
(+ (term a)
(sum term (next a) next b)))))
Using the abstracted form
(define
(define
(define
(define
id (lambda(x) x))
add1 (lambda (x) (+ x 1)))
pi-term (lambda (x) (/ 1 (* x (+ x 2)))))
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 + 0 2 2) ==> 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
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 ( (<var1> <exp1>)
(<var2> <exp2>)
...
(<varn> <expn>) )
<body> )
Let vs. Anonymous Lambda
Let
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))
))
Notes about Let
• let provides variables (declaration and
scope)
• <expi> are in outer scope.
• <body> 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‬‬