sicp-ex-3.50

meteorgan



(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))))))

Beckett

argstreams is a list of list, not a stream, we should not use stream-xxx procs on it.

(define (stream-map proc . argstreams)
(if (stream-null? (car argstreams))
the-empty-stream
(cons-stream
(proc (map car argstreams))
(apply stream-map (cons proc (map cdr argstreams)))
)))

Patrick-OHara

That implementation assumes that the streams are the same length (perhaps infinite). In order to cope with streams of different lengths I have this:

 (define (filter predicate list) 
   (cond ((null? list) 
          '()) 
         ((predicate (car list)) 
          (cons (car list) (filter predicate (cdr list)))) 
         (else 
          (filter predicate (cdr list))))) 
 (define (stream-map proc . argstreams) 
   (let ((non-null-args (filter (lambda (s) (not (stream-null? s))) argstreams))) 
     (if (null? non-null-args) 
       the-empty-stream 
       (cons-stream 
        (apply proc (map stream-car non-null-args)) 
        (apply stream-map 
               (cons proc (map stream-cdr non-null-args)))))))

Shade

A bit cleaner:

  
 (define (any? pred lst)  
   (cond ((null? lst) #f)   
         ((pred (car lst)) #t) 
         (else (any? pred (cdr lst))))) 
  
 (define (stream-map proc . streams)  
   (if (any? stream-null? streams)  
       empty-stream 
       (stream-cons 
         (apply proc (map stream-car streams)) 
         (apply stream-map  
                proc ; We don't need to cons proc and the result of map. 
                (map stream-cdr streams)))))

sanggggg

to Beckett, i think argstream is a list of stream not list of list. so it is correct to map it by stream-xxx. (map each stream by stream-xxx)