Pasted

#lang racket
(require "4-2-3-lazy-lists-repl-program.rkt")
 
;;;;;;;;;;
;; 4.32 ;;
;;;;;;;;;;
 
;; The difference is that the car is lazy as well as the cdr.  For example the book
;; example of integral and solve now works without having to delay the integrand.
 
;; Also, as the book mentions, if you implemented a binary tree as a cons of the left
;; branch with the right branch, you could now have lazy trees.
 
;;;;;;;;;;
;; 4.33 ;;
;;;;;;;;;;
 
;; The quoted clause in my-eval had to be changed to take the environment as a
;; parameter:
 
        ;; [(quoted? expr) (text-of-quotation expr env)]
 
;; text-of-quotation also had to be changed:
 
(define (list->lazy-list xs)
  (if (empty? xs)
    empty
    (list 'my-cons
          (first xs)
          (list->lazy-list (rest xs)))))
 
(define (text-of-quotation expr env)
  (define toq (second expr))
  (if (pair? toq)
    (my-eval (list->lazy-list toq) env)
    toq))
 
;; text-of-quotation needs access to the environment because a lazy pair is
;; implemented as a compound procedure and compound procedures possess an enclosing
;; environment.
 
;;;;;;;;;;
;; 4.34 ;;
;;;;;;;;;;
 
;; A lazy list is an application of my-cons.
 
;; Change the definition of my-cons to use a distinctive parameter name:
 
'(define (my-cons x y)
   (lambda (i-am-a-lazy-list)
     (i-am-a-lazy-list x y)))
 
;; Now we have a way to recognize lazy-lists:
 
(define (lazy-list? obj)
  (and (compound-procedure? obj)
       (eq? (first (procedure-parameters obj))
            'i-am-a-lazy-list)))
 
;; To select the my-car and my-cdr of a lazy list, look up x and y in the environment
;; of the lazy list.  I got this idea from Felix021 on schemewiki. 
 
(define (lazy-list-my-car lzl)
  (force-it (lookup-variable-value 'x (procedure-environment lzl))))
 
(define (lazy-list-my-cdr lzl) ; never display this
  (force-it (lookup-variable-value 'y (procedure-environment lzl))))
 
;; To make lazy-list-my-cdr work, I had to make the empty list self-evaluating:
 
(define (self-evaluating? expr)
  (or (number? expr)
      (string? expr)
      (empty? expr)))
 
;; Now we can transfrom a lazy list into something printable:
 
(define (lazy-list->list lzl [num 10]) ; do not accumulate more than num elements
  (define (loop acc rst n)
    (cond [(zero? n) (reverse (cons '... acc))]
          [(empty? rst) (reverse acc)]
          [(self-evaluating? rst)
           (reverse (cons rst (cons "." acc)))]
          [else
            (loop (cons (lazy-list-my-car rst) acc)
                  (lazy-list-my-cdr rst)
                  (sub1 n))]))
  (loop empty lzl num))
 
;; Because of infinite lists, we terminate the display after at most ten elements.
 
;; Change user-print in repl operations to handle lazy lists:
 
(define (user-print object)
  (cond [(lazy-list? object)
         (displayln (lazy-list->list object))]
        [(compound-procedure? object)
         (displayln (list 'compound-procedure
                          (procedure-parameters object)
                          (procedure-body object)
                          '<procedure-env>))]
        [else (displayln object)]))
 
;; (driver-loop)
;; ;;; L-Eval input:
;; '(1 2 3)
;; ;;; L-Eval value:
;; (1 2 3)
;; ;;; L-Eval input:
;; (my-cons 1 2)
;; ;;; L-Eval value:
;; (1 . 2)
;; ;;; L-Eval input:
;; '(1 2 3 4 5 6 7 8 9 10 11 12)
;; ;;; L-Eval value:
;; (1 2 3 4 5 6 7 8 9 10 ...)
;; ;;; L-Eval input:
;; '(1 "a" 23 "xyz")
;; ;;; L-Eval value:
;; (1 a 23 xyz)
;; ;;; L-Eval input:
;; (my-cons 1 "a")
;; ;;; L-Eval value:
;; (1 . a)