Normal Order (Lazy) Evaluation SICP. Applicative Order vs. Normal (Lazy) Order. Applicative vs. Normal? How can we implement lazy evaluation?

Size: px

Start display at page:

Download "Normal Order (Lazy) Evaluation SICP. Applicative Order vs. Normal (Lazy) Order. Applicative vs. Normal? How can we implement lazy evaluation?"

Lorin Heath
6 years ago
Views:

1 Normal Order (Lazy) Evaluation Alternative models for computation: Normal (Lazy) Order Evaluation Memoization Streams Applicative Order: evaluate all arguments, then apply operator Normal Order: pass unevaluated ression to function evaluate only when needed for primitive operation 1 2 Applicative Order vs. Normal (Lazy) Order Applicative vs. Normal? (define (foo x) (write-line "") (+ x x)) (define (try a b) (if (= a 0) 1 b)) (foo (begin (write-line "") 222)) (try 0 (/ 1 0)) Applicative Order: We first evaluated argument, then substituted value into the body of the procedure Normal (Lazy) Order: As if we substituted the unevaluated ression in the body of the procedure 3 (try 0 (pi-to-this-many-digits )) 4 Exercise Problem with Applicative Order Why cant we use define to define any special form? E.g write a procedure safe/ that only divide if b <> 0 (define (unless pred usual exc) (if pred exc usual)) (define (safe/ a b) (unless (= b 0) (/ a b) 0) (define (safe/ a b) (cond ((= b 0) 0) (else (/ a b)))) How can we implement lazy evaluation? (define (l-apply procedure arguments ) ; changed (cond ((primitive-procedure? procedure) (apply-primitive-procedure procedure (list-of-arg-values arguments ))) ((compound-procedure? procedure) (l-eval-sequence (procedure-body procedure) (extend-ironment (procedure-parameters procedure) (list-of-delayed-args arguments ) (procedure-ironment procedure)))) (else (error "Unknown proc" procedure)))) 5 6

2 Thunks a delayed argument Abstractly a thunk is a "promise" to return a value when later needed ("forced") Concretely our representation: thunk (delay-it ) promise to eval later (force-it ) eval now, leave no thunks Thunks delay-it and force-it (define (delay-it ) (list 'thunk )) (define (thunk? obj) (tagged-list? obj 'thunk)) (define (thunk- thunk) (cadr thunk)) (define (thunk- thunk) (caddr thunk)) (cond ((thunk? obj) (thunk- obj))) (define (actual-value ) (force-it (l-eval ))) 7 8 Exercise Applicative vers Normal Order Write a function normal-order? That returns #t if the language is normal order and #f if the language is applicative order. (define (normal-order?) (let ((x #t)) ((lambda (x) ()) (begin (set! x #f) ())) x)) Memo-izing evaluation In lazy evaluation an arg is reevaluate each time it is used In applicative order evaluation argument is evaluated once Can we keep track of values once we ve obtained them, and avoid cost of reevaluation? thunk 9 evaluatedthunk result 10 Thunks Memoizing Implementation (define (evaluated-thunk? obj) (tagged-list? obj 'evaluated-thunk)) (define (thunk-value evaluated-thunk) (cadr evaluated-thunk)) (cond ((thunk? obj) (let ((result (thunk- obj)))) (set-car! obj 'evaluated-thunk) (set-car! (cdr obj) result) (set-cdr! (cdr obj) '()) result)) ((evaluated-thunk? obj) (thunk-value obj)) Laziness and Language Design We have a dilemma with lazy evaluation Advantage: only do work when value actually needed Disadvantages not sure when ression will be evaluated; can be very big issue in a language with side effects may evaluate same ression more than once Memoization doesn't fully resolve our dilemma Advantage: Evaluate ression at most once Disadvantage: What if we want evaluation on each use? Alternative approach: give programmer control! 11 12

3 Variable Declarations: lazy and lazy- memo Handle lazy and lazy-memo extensions in an upwardcompatible fashion.; (lambda (a (b lazy) c (d lazy-memo))...) "a", "c" are the usual kind of variables (evaluated before procedure application "b" is lazy, Normal Order : it gets (re)-evaluated each time its value is actually needed "d" is lazy-memo; it gets evaluated the first time its value is needed, and then that value is returned again any other time it is needed again. Syntax Extensions Parameter Declarations (define (first-variable var-decls) (car var-decls)) (define (rest-variables var-decls) (cdr var-decls)) (define declaration? pair?) (define (parameter-name var-decl) (if (pair? var-decl) (car var-decl) var-decl)) (define (lazy? var-decl) (and (pair? var-decl) (eq? 'lazy (cadr var-decl)))) (define (memo? var-decl) (and (pair? var-decl) (eq? 'lazy-memo (cadr var-decl)))) Controllably Memo-izing Thunks A new version of delay-it thunk thunk-memo evaluated-thunk when forced never gets memoized first eval is remembered memoized-thunk that has already been evaluated thunkmemo Look at the variable declaration to do the right thing... (define (delay-it decl ) (cond ((not (declaration? decl)) (l-eval )) ((lazy? decl) (list 'thunk )) ((memo? decl) (list 'thunk-memo )) (else (error "unknown declaration:" decl)))) evaluatedthunk result Change to force-it (cond ((thunk? obj) ;eval, but don't remember it (thunk- obj))) ((memoized-thunk? obj) ;eval and remember (let ((result (thunk- obj)))) (set-car! obj 'evaluated-thunk) (set-car! (cdr obj) result) (set-cdr! (cdr obj) '()) result)) ((evaluated-thunk? obj) (thunk-value obj)) Order Comparison (define (foo x) (write-line "") (+ x x)) (foo (begin (write-line "") 222)) Applicative Order: Normal (lazy) Order: Memoized Normal (Lazy-memo) Order: 17 18

4 Exercise Stream Object Given this definition of l-abs: (define (l-abs (i lazy)) (if (< i 0) (- i) i)) A pair-like object, except the cdr part is lazy (not evaluated until needed): cons-stream Trace the following use of l-abs: (define (down) (begin (set! x (- x 2)) x) (define x 3) (l-abs (down)) stream-car a value (define x (y lazy-memo)) (cons x y)) (define stream-car car) (define stream-cdr cdr) stream-cdr a thunk-memo What will these print? (ex1) (define s (cons 5 (begin (write-line 7) 9))) (car s) (cdr s) (define t 5 (begin (write-line 7) 9))) (stream-car t) (stream-cdr t) Can separate order of events in computer from apparent order of events in procedure description (list-ref (filter (lambda (x) (prime? x)) (enumerate-interval )) 100) (stream-ref (stream-filter (lambda (x) (prime? x)) (stream-interval )) 100) (define (stream-interval a b) (if (> a b) the-empty-stream a (stream-interval (+ a 1) b)))) (define (filter-stream pred str) (if (pred (stream-car str)) (stream-car str) (filter-stream pred (stream-cdr str))) (filter-stream pred (stream-cdr str)))) (define seq (stream-interval 1 10)) (define y (stream-filter even? seq)) Now! Lets do some calculation... (stream-ref y 3) ->

5 Creating streams There are two basic ways to create streams: Creating infinite streams (define ones s 1 ones)) 1. Build them up from scratch 2. Modify or combine existing streams (define (add-streams s1 s2) (+ (stream-car s1) (stream-car s2)) (add-streams (stream-cdr s1) (stream-cdr s2))))) (define integers 1 (add-streams ones integers)) Creating fibonacci streams (ex4) Creating fibonacci streams Write a procedure, (fibs), that returns a stream of Fibonacci numbers. The Fibonacci series goes Write a procedure, (fibs), that returns a stream of Fibonacci numbers. The Fibonacci series goes ( ) ( ) It starts with two 1's, then each successive value is the sum of the previous two. It starts with two 1's, then each successive value is the sum of the previous two. (define fibs 0 1 (add-stream (stream-cdr fibs) fibs)))) Add-Streams == Map2 (add-streams integers integers) == (map2-stream + integers integers) (define (map2-stream proc str1 str2) (proc (stream-car str1) (stream-car str2)) (map-stream2 proc (stream-cdr str1) (stream-cdr str2)))) 29

6.037 Lecture 7B. Scheme Variants Normal Order Lazy Evaluation Streams

6.037 Lecture 7B. Scheme Variants Normal Order Lazy Evaluation Streams 6.037 Lecture 7B Scheme Variants Normal Order Lazy Evaluation Streams Edited by Mike Phillips & Ben Vandiver Original Material by Eric Grimson & Duane Boning Further Variations on a Scheme Beyond Scheme