Мемоизация результатов вычислений

(use-syntax (ice-9 syncase))
(define memoized-factorial
  (let ((l '()))
    (lambda (a)
        (if (<= a 1) 1 (if (assq a l)
                        (cadr (assq a l))
                        (let ((f (* a (memoized-factorial (- a 1)))))
                        (set! l (cons (list a f) l))
                        f))))))

(define-syntax lazy-cons
  (syntax-rules ()
    ((lazy-cons a b)
     (cons a (delay b)))))

(define (lazy-car p)
  (car p))

(define (lazy-cdr p)
  (force (cdr p)))

(define (lazy-head xs k)
  (define (iter i xs l)
    (if (= i k)
        l
        (iter (+ i 1) (lazy-cdr xs) (append l (list (lazy-car xs))))))
  (iter 0 xs '()))


(define (lazy-ref xs k)
  (define (iter i xs)
    (if (= i k)
        (lazy-car xs)
        (iter (+ i 1) (lazy-cdr xs))))
  (iter 0 xs))

(define (naturals n)
  (lazy-cons n (naturals (+ n 1))))

(define (lazy-f n s)
  (lazy-cons s (lazy-f (+ n 1) (* s (+ n 1)))))

(define (lazy-factorial n)
  (lazy-ref (lazy-f 0 1) n))