(define (integers-from n)
  (cons n (delay (integers-from (+ n 1)))))

(define jrm-stream-ref
  (letrec ((loop (lambda (stream index)
                   (cond ((not (pair? stream)) (error 'stream-ref 0))
                         ((zero? index) (car stream))
                         (else (loop (force (cdr stream)) (- index 1)))))))
    loop))

(define jrm-stream-filter
  (letrec ((loop (lambda (predicate stream)
                   (cond ((not (pair? stream))
                          (if (null? stream)
                              '()
                              (error stream 'stream-filter 1)))
                         ((predicate (car stream))
                          (cons (car stream)
                                (delay (loop predicate (force (cdr stream))))))
                         (else (loop predicate (force (cdr stream))))))))
    loop))

(define (demo-stream-problem n)
  (jrm-stream-ref
    (jrm-stream-filter
      (lambda (x) (zero? (modulo x n)))
      (integers-from 0))
    3))

(demo-stream-problem n) consumes O(n) memory rather than constant
memory.  I believe that it ought not do so (though I understand
the mechanism through which it does), but that `fixing' the problem
is very difficult (though I believe it *can* be done, albiet with
considerable work).  The reason that I believe that it ought not
run in O(n) time is because computing element n+1 of the integers
stream requires only the single prior element and filtering a
stream requires none of the prior elements.

I have actually run and tested this code on multiple scheme
implementations with the same results.  (The prior posting I
just tested on one implementation.  Mea culpa.)