Create ranged list scheme

Does anyone have a faster technique to build a list between a start and stop value? 
I made the straight forward

[code]

(define (mkrng min max)
  (cond
   ((< max min) '())
   (else(cons max (mkrng min (- max 1)))))) [\code]
 
But it is really slow for my application which needs lists of tens of millions of numbers

One way is to use delay and force.

(define (make-range x y)
  (if (> x y)
    '()
    (cons x (delay (make-range (+ x 1) y)))))

This will return a pair of x and a "promise" to evaluate (make-range (+ x 1) y) later. You can evaluate it by calling (force (cdr range)), where range is the pair returned by make-range.

Here's an example of how you would use it:

(define (sum-of-range range)
  (if (null? range)
    0
    (+ (car range)
       (sum-of-range (force (cdr range))))))

but here is an attempt at creating a lazy list in scheme...


;; a lazy cell consists of a pair (x . xs)
;; where x is an evaluated value that can be accessed,
;; and xs is a function that takes no arguments, that will generate
;; the next lazy cell.

(define lazy-car car)
(define lazy-cdr (lambda (cell)
                    (if (null? (cdr cell))
                         '()
                         ((cdr cell)))))


(define (lazy-range low high)
  (if (> low high)
      '()
      (cons low
            (lambda ()
              (lazy-range (+ 1 low) high)))))

(define (lazy-for-each operator lazy-lis)
  (if (not (null? lazy-lis))
    (begin (operator (lazy-car lazy-lis))
           (lazy-for-each operator (lazy-cdr lazy-lis)))))


(lazy-for-each (lambda (x) (display x) (newline)) (lazy-range 1 20))

lazy-map and friends, coming soon...

>>7
well that is handy! please ignore >>8 op.