מבוא מורחב - שיעור 15 1 Lecture 15 Streams

מבוא מורחב - שיעור 15 2 Streams: Motivation (define (sum-primes a b) (define (iter count accum) (cond ((> count b) accum) ((prime? count) (iter (+ count 1) (+ count accum))) (else (iter (+ count 1) accum)))) (iter a 0)) (define (sum-primes a b) (accumulate + 0 (filter prime? (enumerate-interval a b)))) Second implementation consumes a lot of storage

מבוא מורחב - שיעור 15 3 Streams: Motivation (Cont.) (car (cdr (filter prime? (enumerate-interval )))) Requires a lot of time and space How can we gain the efficiency of iteration, and retain the elegance of sequence-operations? Streams!

מבוא מורחב - שיעור 17 4 Remember normal order evaluation? Normal (Lazy) Order Evaluation: go ahead and apply operator with unevaluated argument subexpressions evaluate a subexpression only when value is needed –to print –by primitive procedure (that is, primitive procedures are "strict" in their arguments) Compromise approach: give programmer control between normal and applicative order. Streams: lists with delays

מבוא מורחב - שיעור 15 5 Streams interface Constructors: the-empty-stream (cons-stream x y) Predicate: ( stream-null? x) cons-stream treats its second argument as a delayed object. Selectors: (stream-car (cons-stream x y)) = x (stream-cdr (cons-stream x y)) = y

מבוא מורחב - שיעור 15 6 Streams via delay and force (cons-stream ) is a special form equivalent to (cons (delay )) (define (stream-car stream) (car stream)) (define (stream-cdr stream) (force (cdr stream)))

מבוא מורחב - שיעור 15 7 delay and force (delay ) ==> a promise to evaluate exp (force ) ==> evaluate the delayed object and return the result (define x (delay (+ 1 1))) x  # (force x)  2 (delay ) is a special form. force is not a special form.

מבוא מורחב - שיעור 15 8 What are these mysterious delay and force ? delay is a special form such that (delay ) is equivalent to (lambda () ) force is a procedure that calls a procedure produced by delay: (define (force delayed-object) (delayed-object))

מבוא מורחב - שיעור 15 9 Let us recall lists (define (enumerate-interval low high) (if (> low high) ‘() (cons low (enumerate-interval (+ low 1) high)))) (define int123 (enumerate-interval 1 3)) (enumerate-interval 1 3) (cons 1 (enumerate-interval 2 3)) (cons 1 (cons 2 (enumerate-interval 3 3))) (cons 1 (cons 2 (cons 3 (enumerate-interval 4 3))) (cons 1 (cons 2 (cons 3 ‘())))

מבוא מורחב - שיעור Enumerating with streams (define (stream-enumerate-interval low high) (if (> low high) the-empty-stream (cons-stream low (stream-enumerate-interval (+ low 1) high)))) (define s (stream-enumerate-interval 1 3)) (stream-enumerate-interval 1 3) (cons-stream 1 (stream-enumerate-interval 2 3)) (cons 1 (delay (stream-enumerate-interval 2 3))) (cons 1 (lambda () (stream-enumerate-interval 2 3)))

מבוא מורחב - שיעור (define s (stream-enumerate-interval 1 3)) | GE GE p: low high b : (if (> low high) the-empty-stream (cons-stream... ) stream-enumerate-interval: (cons-stream 1 (str-enu-int (+ low 1) high))| E1 (cons 1 (lambda () (str-enu-int (+ low 1) high)) | E1 p: b: (str-enu_int (+ low 1) high) s: 1 low 1 high 3 E1

מבוא מורחב - שיעור (define s1 (stream-cdr s)) (stream-cdr s) (stream-cdr (cons 1 (lambda () (str-enu-int 2 3)))) (force (cdr (cons 1 (lambda () (str-enu-int 2 3))))) (force (lambda () (str-enu-int 2 3))) ((lambda () (str-enu-int 2 3))) (str-enu-int 2 3) (cons-stream 2 (str-enu-int 3 3)) (cons 2 (delay (str-enu-int 3 3))) (cons 2 (lambda () (str-enu-int 3 3))) Calling stream-cdr

מבוא מורחב - שיעור (define s1 (stream-cdr s)) | GE (force (cdr s)) | GE GE p: low high b : (if (> low high) the-empty-stream (cons-stream... ) str-enu-int: s: E1 low 1 1 high 3 p: b:(str-enu-int (+ low 1) high) 2 low 2 high 3 s1:

מבוא מורחב - שיעור stream-ref, stream-map (define (stream-ref s n) (if (= n 0) (stream-car s) (stream-ref (stream-cdr s) (- n 1)))) (define (stream-map proc s) (if (stream-null? s) the-empty-stream (cons-stream (proc (stream-car s)) (stream-map proc (stream-cdr s)))) Also a version with multiple stream arguments

מבוא מורחב - שיעור Stream-filter (define (stream-filter pred stream) (cond ((stream-null? stream) the-empty-stream) ((pred (stream-car stream)) (cons-stream (stream-car stream) (stream-filter pred (stream-cdr stream)))) (else (stream-filter pred (stream-cdr stream)))))

מבוא מורחב - שיעור Applicative vs. Normal order evaluation. (stream-car (stream-cdr (stream-filter prime?(str-enu-int )))) (car (cdr (filter prime? (enu-int )))) Both return the second prime larger or equal to 10 (which is 13) With lists it takes about operations With streams about three.

מבוא מורחב - שיעור How does it work? - I (stream-car (stream-cdr (stream-filter prime? (str-enu-int )))) (stream-car (stream-cdr (stream-filter prime? (cons 10 (delay (str-enu-int )))))) (stream-car (stream-cdr (stream-filter prime? (force (lambda () (str-enu-int )))))) (stream-car (stream-cdr (stream-filter prime? (cons 11 (delay (str-enu-int ))))))

מבוא מורחב - שיעור How does it work? - II (stream-car (stream-filter prime? (stream-cdr (cons 11 (delay (str-enu-int )))))) (stream-car (stream-cdr (cons 11 (delay (stream-filter prime? (stream-cdr (cons 11 (delay (str-enu-int ))))))))) (stream-car (stream-filter prime? (str-enu-int )))

מבוא מורחב - שיעור How does it work? - III (stream-car (stream-filter prime? (cons 12 (delay (str-enu-int ))))) (stream-car (stream-filter prime? (str-enu-int ))) (stream-car (stream-filter prime? (cons 13 (delay (str-enu-int ))))) (stream-car (cons 13 (delay (stream-filter prime? (stream-cdr (cons 13 (delay (str-enu-int )))))))) 13

Memoization Suppose we have the following scenario: (define x (delay (very-hard-function a))) (force x) We need to call the hard function twice. Scheme will automatically detect that this is the second time we try to evaluate the function and use the value we have evaluated before.

How is it done? delay is actually defined as follows: (delay ) translates to (memo-proc (lambda () )) (define (memo-proc proc) (let ((already-run? #f) (result #f)) (lambda () (if (not already-run?) (begin (set! result (proc)) (set! already-run? true) result) result))))

מבוא מורחב - שיעור Infinite streams Since streams are delayed, we are not limited to finite streams!! Some objects are more naturally infinite

מבוא מורחב - שיעור The integers (define (integers-from n) (cons-stream n (integers-from (+ n 1)))) (define integers (integers-from 1))

מבוא מורחב - שיעור Integers not divisible by 7 (define (divisible? x y) (= (remainder x y) 0)) (define no-sevens (stream-filter (lambda (x) (not (divisible? x 7))) integers)) (stream-ref no-sevens 100)  117

מבוא מורחב - שיעור Fibonacci sequence (define (fib-seq-from a b) (cons-stream a (fib-seq-from b (+ a b)))) (define fib-seq (fib-seq-from 0 1))

מבוא מורחב - שיעור Fibonacci sequence  (define (fib-seq-from a b) (cons-stream a (fib-seq-from b (+ a b))))  (define fib-seq (fib-seq-from 0 1))  fib-seq (0. # [fib-seq-from 1 1])  (stream-ref fib-seq 3) (stream-ref (stream-cdr fib-seq) 2) (stream-ref (fib-seq-from 1 1) 2) (stream-ref (cons 1 (delay (fib-seq-from 1 2))) 2) (stream-ref (stream-cdr (cons 1 (delay (fib-seq-from 1 2)) 1) (stream-ref (fib-seq from 1 2) 1) (stream-ref (cons 1 (delay (fib-seq from 2 3))) 1) (stream-ref (stream-cdr (cons 1 (delay (fib-seq-from 2 3)))) 0) (stream-ref (fib-seq-from 2 3) 0) (stream-ref (cons 2 (delay (fib-seq-from 3 5))) 0) 2

מבוא מורחב - שיעור Finding all the primes using the sieve of Eratosthenes

מבוא מורחב - שיעור The sieve of Eratosthenes using streams (define (sieve str) (cons-stream (stream-car str) (sieve (stream-filter (lambda (x) (not (divisible? x (stream-car str)))) (stream-cdr str))))) (define primes (sieve (stream-cdr integers)))

מבוא מורחב - שיעור The integers, again (implicit version) We saw the definition: (define (integers-from n) (cons-stream n (integers-from (+ n 1)))) (define integers (integers-from 1)) An alternative definition: (define integers (cons-stream 1 (stream-map (lambda (x) (+ x 1)) integers)) (integers) integers input to stream-map result: element