SICP stream question

[Chris Baker]

I'm trying to implement streams (delayed lists) from SICP.  Here's what I have 
so far:

        ;;; stream definitions
        (define cons-stream
          (procedure->macro
           (lambda (x env) `(cons ,(cadr x) (delay ,(caddr x))))))
        
        (define (stream-car stream) (car stream))
        (define (stream-cdr stream) (force (cdr stream)))
        
        (define (stream-filter pred stream)
          (cond ((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)))))
        
        (define (stream-ref stream n)
          (if (< n 1)
              (stream-car stream)
              (stream-ref (stream-cdr stream) (- n 1))))
        
        ;;; testing
        (define (divisible? x y) (= (remainder x y) 0))
        
        (define (integers-from-n n)
          (cons-stream n (integers-from-n (+ n 1))))
        
        (define integers (integers-from-n 1))
        
        (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-from-n 2)))
        
        ;;; end

Now, in SCM, it works:

        SCM version 5d2, Copyright (C) 1990-1999 Free Software Foundation.
        SCM comes with ABSOLUTELY NO WARRANTY; for details type `(terms)'.
        This is free software, and you are welcome to redistribute it
        under certain conditions; type `(terms)' for details.
        ;loading /usr/share/slib/require
        ;done loading /usr/share/slib/require.scm
        ;loading /usr/lib/scm/Link
        ;done loading /usr/lib/scm/Link.scm
        ;loading /usr/lib/scm/Transcen
        ;done loading /usr/lib/scm/Transcen.scm
        ;Evaluation took 80 mSec (0 in gc) 17689 cells work, 12092 env, 19884 
bytes other
        > (load "stream.scm")
        ;loading stream.scm
        ;done loading stream.scm
        ;Evaluation took 0 mSec (0 in gc) 449 cells work, 45 env, 556 bytes 
other
        #<unspecified>
        > (stream-ref primes 200)
        ;Evaluation took 900 mSec (340 in gc) 488680 cells work, 1298118 env, 
20049 bytes other
        1229
        >

Cool!

In Guile, I get:

        guile> (load "stream.scm")
        stream.scm:6:45: In procedure caddr in expression (caddr x):
        stream.scm:6:45: Wrong type argument in position 1: (address@hidden n 
(integers-from-n (+ n 1)))
        ABORT: (wrong-type-arg)
        
        Type "(backtrace)" to get more information.
        guile> 
        
I'm new to macros, so I'm guessing the problem's there somewhere.  Any ideas?

TIA,

cbb