Implement till 3.52

ex-3_50-xx.scm

@@ -1,5 +1,108 @@
 (load "util.scm")
 
-(display "\nex-3.50\n")
+(display "\nex-3.50 - stream-map\n")
 
+(define (stream-enumerate-interval low high)
+  (if (> low high)
+      the-empty-stream
+      (cons-stream
+       low
+       (stream-enumerate-interval (+ low 1) high))))
+
+(define (stream-map proc . argstreams)
+  (if (stream-null? (car argstreams))
+      the-empty-stream
+      (cons-stream
+       (apply proc (map stream-car argstreams))
+       (apply stream-map
+              (cons proc (map stream-cdr argstreams))))))
+
+(define (stream-to-list xs)
+  (if (stream-null? xs)
+    '()
+    (cons (stream-car xs)
+          (stream-to-list (stream-cdr xs)))))
+
+(assert (stream-to-list (stream-enumerate-interval 1 3))
+        '(1 2 3))
+
+(assert (stream-to-list
+           (stream-map (lambda (x y) (* x y))
+                       (stream-enumerate-interval 1 3)
+                       (stream-enumerate-interval -3 -1)))
+        '(-3 -4 -3))
+
+(display "\nex-3.51\n")
+
+(define (show x)
+  (display-line x)
+  x)
+
+(define (stream-ref s n)
+  (if (= n 0)
+      (stream-car s)
+      (stream-ref (stream-cdr s) (- n 1))))
+
+(define x (stream-map show (stream-enumerate-interval 0 10)))
+
+(stream-ref x 5)
+; 0
+; 1
+; 2
+; 3
+; 4
+; 5
+
+(stream-ref x 7)
+; 6
+; 7
+
+(display "\nex-3.52\n")
+
+(define (display-stream s)
+  (stream-for-each display-line s))
+
+(define sum 0)
+
+(define (accum x)
+  (set! sum (+ x sum))
+  sum)
+
+(define seq (stream-map accum (stream-enumerate-interval 1 20)))
+; 1 3 6 10 15 21 28 36 45 55 66 78 91 105 120 136 153 171 190 210
+
+(define y (stream-filter even? seq))
+; 6 10 28 36 66 78 120 136 190 210
+
+(define z (stream-filter (lambda (x) (= (remainder x 5) 0))
+                         seq))
+
+(assert (stream-ref y 7) 136)
+(assert (stream-to-list z)
+        '(10 15 45 55 105 120 190 210))
+
+; The responses would differ if we had implemented delay without memo-proc,
+; because the values of the stream would be recomputed for z starting from the
+; last value of sum after defining y.
+
+(display "\nexample - sieve of Eratosthenes\n")
+
+(define (integers-starting-from n)
+  (cons-stream n (integers-starting-from (+ n 1))))
+
+(define (divisible? x y) (= (remainder x y) 0))
+
+(define (sieve stream)
+  (cons-stream
+   (stream-car stream)
+   (sieve (stream-filter
+           (lambda (x)
+             (not (divisible? x (stream-car stream))))
+           (stream-cdr stream)))))
+
+(define primes (sieve (integers-starting-from 2)))
+
+(assert (stream-ref primes 5) 13)
+
+(display "\nex-3.53\n")
 

util.scm

@@ -64,4 +64,8 @@
     ((eq? x (car xs)) #t)
     (else (contains x (cdr xs)))))
 
+(define (display-line x)
+  (display x)
+  (newline))
+
 'util-loaded