1 ;; (define apply-in-underlying-scheme apply)
2 
3 (define (eval exp env)
4   (cond ((self-evaluating? exp) exp)
5         ((variable? exp) (lookup-variable-value exp env))
6         ((quoted? exp) (text-of-quotation exp))
7         ((assignment? exp) (eval-assignment exp env))
8         ((definition? exp) (eval-definition exp env))
9 	((unbound? exp) (eval-unbound exp env))
10         ((if? exp) (eval-if exp env))
11 	((and? exp) (eval-and exp env))
12 	((or? exp) (eval-or exp env))
13         ((lambda? exp)
14          (make-procedure (lambda-parameters exp)
15                          (lambda-body exp)
16                          env))
17         ((begin? exp) 
18          (eval-sequence (begin-actions exp) env))
19         ((cond? exp) (eval (cond->if exp) env))
20 	((let? exp) (eval (let->combination exp) env))
21 	((let*? exp) (eval (let*->nested-lets exp) env))
22 	((named-let? exp) (eval (named-let->combination exp) env))
23 	((do? exp) (eval (do->combination exp) env))
24         ((application? exp)
25          (apply (eval (operator exp) env)
26                 (list-of-values (operands exp) env)))
27         (else
28          (error "Unknown expression type -- EVAL" exp))))
29 (define (apply procedure arguments)
30   (cond ((primitive-procedure? procedure)
31          (apply-primitive-procedure procedure arguments))
32         ((compound-procedure? procedure)
33          (eval-sequence
34            (procedure-body procedure)
35            (extend-environment
36              (procedure-parameters procedure)
37              arguments
38              (procedure-environment procedure))))
39         (else
40          (error
41           "Unknown procedure type -- APPLY" procedure))))
42 
43 (define (list-of-values exps env)
44   (if (no-operands? exps)
45       '()
46       (cons (eval (first-operand exps) env)
47             (list-of-values (rest-operands exps) env))))
48 
49 (define (tagged-list? exp tag)
50   (if (pair? exp)
51       (eq? (car exp) tag)
52       false))
53 
54 ;; self-evaluating/variable/quoted
55 (define (self-evaluating? exp)
56   (cond ((number? exp) true)
57         ((string? exp) true)
58         (else false)))
59 (define (variable? exp) (symbol? exp))
60 (define (quoted? exp)
61   (tagged-list? exp 'quote))
62 (define (text-of-quotation exp) (cadr exp))
63 
64 ;; assignment/definition
65 (define (assignment? exp)
66   (tagged-list? exp 'set!))
67 (define (assignment-variable exp) (cadr exp))
68 (define (assignment-value exp) (caddr exp))
69 (define (definition? exp)
70   (tagged-list? exp 'define))
71 (define (definition-variable exp)
72   (if (symbol? (cadr exp))
73       (cadr exp)
74       (caadr exp)))
75 (define (definition-value exp)
76   (if (symbol? (cadr exp))
77       (caddr exp)
78       (make-lambda (cdadr exp)   ; formal parameters
79                    (cddr exp)))) ; body
80 (define (eval-assignment exp env)
81   (set-variable-value! (assignment-variable exp)
82                        (eval (assignment-value exp) env)
83                        env)
84   'ok)
85 (define (eval-definition exp env)
86   (define-variable! (definition-variable exp)
87                     (eval (definition-value exp) env)
88                     env)
89   'ok)
90 (define (make-definition var val)
91   `(define ,var ,val))
92 
93 ;; make-unbound!
94 
95 (define (unbound? exp)
96   (tagged-list? exp 'make-unbound!))
97 (define (unbound-var exp)
98   (cadr exp))
99 (define (eval-unbound exp env)
100   (remove-binding-from-frame! (unbound-var exp) (first-frame env)))
101 (define (remove-binding-from-frame! var frame)
102   (define (scan vars vals)
103     (cond ((null? (cdr vars))
104 	   (error "Binding not found -- REMOVE-BINDING-FROM-FRAME!" var))
105 	  ((eq? var (cadr vars))
106 	   (set-cdr! vars (cddr vars))
107 	   (set-cdr! vals (cddr vals)))
108 	  (else (scan (cdr vars) (cdr vals)))))
109   (let ((vars (frame-variables frame))
110 	(vals (frame-values frame)))
111     (if (eq? var (car vars))
112 	(begin (set-car! frame (cdr vars))
113 	       (set-cdr! frame (cdr vals)))
114 	(scan vars vals))))
115 
116 ;; if/and/or
117 (define (if? exp) (tagged-list? exp 'if))
118 (define (if-predicate exp) (cadr exp))
119 (define (if-consequent exp) (caddr exp))
120 (define (if-alternative exp)
121   (if (not (null? (cdddr exp)))
122       (cadddr exp)
123       'false))
124 (define (make-if predicate consequent alternative)
125   (list 'if predicate consequent alternative))
126 (define (eval-if exp env)
127   (if (true? (eval (if-predicate exp) env))
128       (eval (if-consequent exp) env)
129       (eval (if-alternative exp) env)))
130 
131 (define (and? exp)
132   (tagged-list? exp 'and))
133 (define (and-clauses exp)
134   (cdr exp))
135 (define (or? exp)
136   (tagged-list? exp 'or))
137 (define (or-clauses exp)
138   (cdr exp))
139 (define (eval-and exp env)
140   (define (eval-clauses clauses)
141     (cond ((null? clauses) true)
142 	  ((null? (cdr clauses)) (eval (car clauses) env))
143 	  (else (and (eval (car clauses) env)
144 		     (eval-clauses (cdr clauses))))))
145   (eval-clauses (and-clauses exp)))
146 (define (eval-or exp env)
147   (define (eval-clauses clauses)
148     (if (null? clauses)
149 	false
150 	(or (eval (car clauses) env)
151 	    (eval-clauses (cdr clauses)))))
152   (eval-clauses (or-clauses exp)))
153 
154 
155 ;; lambda/let/let*
156 (define (lambda? exp) (tagged-list? exp 'lambda))
157 (define (lambda-parameters exp) (cadr exp))
158 (define (lambda-body exp) (cddr exp))
159 (define (make-lambda parameters body)
160   (cons 'lambda (cons parameters body)))
161 
162 (define (make-let vars vals body)
163   (cons 'let
164 	(cons (map list vars vals)
165 	      body)))
166 (define (let? exp)
167   (and (tagged-list? exp 'let)
168        (not (symbol? (cadr exp)))))
169 (define (let-vars exp)
170   (map car (cadr exp)))
171 (define (let-vals exp)
172   (map cadr (cadr exp)))
173 (define (let-body exp)
174   (cddr exp))
175 (define (let->combination exp)
176   (make-application (make-lambda (let-vars exp) (let-body exp))
177 		    (let-vals exp)))
178 (define (named-let? exp)
179   (and (tagged-list? exp 'let)
180        (symbol? (cadr exp))))
181 (define (named-let-name exp)
182   (cadr exp))
183 (define (named-let-vars exp)
184   (map car (caddr exp)))
185 (define (named-let-vals exp)
186   (map cadr (caddr exp)))
187 (define (named-let-body exp)
188   (cdddr exp))
189 (define (named-let->combination exp)
190   (sequence->exp
191    (list (make-definition (named-let-name exp)
192 			  (make-lambda (named-let-vars exp)
193 				       (named-let-body exp)))
194 	 (make-application (named-let-name exp)
195 			   (named-let-vals exp)))))
196 (define (make-named-let name vars vals body)
197   (cons 'let 
198 	(cons name
199 	      (cons (map list vars vals)
200 		    body))))
201 
202 (define (make-application op args)
203   (cons op args))
204 
205 (define (let*? exp)
206   (tagged-list? exp 'let*))
207 (define let*-vars let-vars)
208 (define let*-vals let-vals)
209 (define let*-body let-body)
210 (define (let*->nested-lets exp)
211   (define (expand-lets vars vals)
212     (if (null? (cdr vars))
213 	(make-let (list (car vars)) 
214 		  (list (car vals))
215 		  (let*-body exp))
216 	(make-let (list (car vars))
217 		  (list (car vals))
218 		  (list (expand-lets (cdr vars) (cdr vals))))))
219   (let ((vars (let*-vars exp))
220 	(vals (let*-vals exp)))
221     (if (null? vars)
222 	(sequence->exp (let*-body exp))
223 	(expand-lets vars vals))))
224 
225 ;; do loop
226 (define (do? exp)
227   (tagged-list? exp 'do))
228 (define (do-vars exp)
229   (map car (cadr exp)))
230 (define (do-inits exp)
231   (map cadr (cadr exp)))
232 (define (do-steps exp)
233   (map (lambda (var-init-step)
234 	 (if (null? (cddr var-init-step))
235 	     (car var-init-step)
236 	     (caddr var-init-step)))
237        (cadr exp)))
238 (define (do-test exp)
239   (caaddr exp))
240 (define (do-expressions exp)
241   (if (null? (cdaddr exp))
242       (caddr exp)
243       (cdaddr exp)))
244 (define (do-commands exp)
245   (cdddr exp))
246 (define (do->combination exp)
247   (make-named-let
248    'do-iter
249    (do-vars exp)
250    (do-inits exp)
251    (list
252     (make-if
253      (do-test exp)
254      (sequence->exp (do-expressions exp))
255      (sequence->exp
256       (append (do-commands exp)
257 	      (list (make-application
258 		     'do-iter
259 		     (do-steps exp)))))))))
260 
261 
262 ;; begin/sequence
263 (define (begin? exp) (tagged-list? exp 'begin))
264 (define (begin-actions exp) (cdr exp))
265 (define (last-exp? seq) (null? (cdr seq)))
266 (define (first-exp seq) (car seq))
267 (define (rest-exps seq) (cdr seq))
268 (define (sequence->exp seq)
269   (cond ((null? seq) seq)
270         ((last-exp? seq) (first-exp seq))
271         (else (make-begin seq))))
272 (define (make-begin seq) (cons 'begin seq))
273 (define (eval-sequence exps env)
274   (cond ((last-exp? exps) (eval (first-exp exps) env))
275         (else (eval (first-exp exps) env)
276               (eval-sequence (rest-exps exps) env))))
277 
278 ;; application
279 (define (application? exp) (pair? exp))
280 (define (operator exp) (car exp))
281 (define (operands exp) (cdr exp))
282 (define (no-operands? ops) (null? ops))
283 (define (first-operand ops) (car ops))
284 (define (rest-operands ops) (cdr ops))
285 
286 ;; cond
287 (define (cond? exp) (tagged-list? exp 'cond))
288 (define (cond-clauses exp) (cdr exp))
289 (define (cond-else-clause? clause)
290   (eq? (cond-predicate clause) 'else))
291 (define (cond-predicate clause) (car clause))
292 (define (cond-actions clause) (cdr clause))
293 (define (cond-extended-clause? clause)
294   (and (not (null? (cdr clause))) (eq? (cadr clause) '=>)))
295 (define (cond-extended-proc clause)
296   (caddr clause))
297 (define (cond->if exp)
298   (expand-clauses (cond-clauses exp)))
299 (define (expand-clauses clauses)
300   (if (null? clauses)
301       'false                          ; no else clause
302       (let ((first (car clauses))
303             (rest (cdr clauses)))
304         (if (cond-else-clause? first)
305             (if (null? rest)
306                 (sequence->exp (cond-actions first))
307                 (error "ELSE clause isn't last -- COND->IF"
308                        clauses))
309 	    (if (cond-extended-clause? first)
310 		(make-if (cond-predicate first)
311 			 (make-application
312 			  (cond-extended-proc first)
313 			  (list (cond-predicate first)))
314 			 (expand-clauses rest))
315 		(make-if (cond-predicate first)
316 			 (sequence->exp (cond-actions first))
317 			 (expand-clauses rest)))))))
318 (define (true? x)
319   (not (eq? x false)))
320 (define (false? x)
321   (eq? x false))
322 
323 ;; procedure
324 (define (make-procedure parameters body env)
325   (list 'procedure parameters (scan-out-defines body) env))
326 (define (compound-procedure? p)
327   (tagged-list? p 'procedure))
328 (define (procedure-parameters p) (cadr p))
329 (define (procedure-body p) (caddr p))
330 (define (procedure-environment p) (cadddr p))
331 
332 ;; environment
333 (define (enclosing-environment env) (cdr env))
334 (define (first-frame env) (car env))
335 (define the-empty-environment '())
336 (define (make-frame variables values)
337   (cons variables values))
338 (define (frame-variables frame) (car frame))
339 (define (frame-values frame) (cdr frame))
340 (define (add-binding-to-frame! var val frame)
341   (set-car! frame (cons var (car frame)))
342   (set-cdr! frame (cons val (cdr frame))))
343 (define (extend-environment vars vals base-env)
344   (if (= (length vars) (length vals))
345       (cons (make-frame vars vals) base-env)
346       (if (< (length vars) (length vals))
347           (error "Too many arguments supplied" vars vals)
348           (error "Too few arguments supplied" vars vals))))
349 (define (lookup-variable-value var env)
350   (define (env-loop env)
351     (define (scan vars vals)
352       (cond ((null? vars)
353              (env-loop (enclosing-environment env)))
354             ((eq? var (car vars))
355 	     (let ((val (car vals)))
356 	       (if (eq? val '*unassigned*)
357 		   (error "Var not yet defined -- LOOKUP-VARIABLE-VALUE" var)
358 		   val)))
359              (car vals))
360             (else (scan (cdr vars) (cdr vals)))))
361     (if (eq? env the-empty-environment)
362         (error "Unbound variable" var)
363         (let ((frame (first-frame env)))
364           (scan (frame-variables frame)
365                 (frame-values frame)))))
366   (env-loop env))
367 (define (set-variable-value! var val env)
368   (define (env-loop env)
369     (define (scan vars vals)
370       (cond ((null? vars)
371              (env-loop (enclosing-environment env)))
372             ((eq? var (car vars))
373              (set-car! vals val))
374             (else (scan (cdr vars) (cdr vals)))))
375     (if (eq? env the-empty-environment)
376         (error "Unbound variable -- SET!" var)
377         (let ((frame (first-frame env)))
378           (scan (frame-variables frame)
379                 (frame-values frame)))))
380   (env-loop env))
381 (define (define-variable! var val env)
382   (let ((frame (first-frame env)))
383     (define (scan vars vals)
384       (cond ((null? vars)
385              (add-binding-to-frame! var val frame))
386             ((eq? var (car vars))
387              (set-car! vals val))
388             (else (scan (cdr vars) (cdr vals)))))
389     (scan (frame-variables frame)
390           (frame-values frame))))
391 
392 ;; primitives
393 (define (primitive-procedure? proc)
394   (tagged-list? proc 'primitive))
395 (define (primitive-implementation proc) (cadr proc))
396 (define primitive-procedures
397   (list (list 'car car)
398         (list 'cdr cdr)
399 	(list 'caar caar)
400 	(list 'cadr cadr)
401 	(list 'cddr cddr)
402         (list 'cons cons)
403         (list 'null? null?)
404 	(list '* *)
405 	(list '/ /)
406 	(list '+ +)
407 	(list '- -)
408 	(list '= =)
409 	(list '< <)
410 	(list '> >)
411 	(list '<= <=)
412 	(list '>= >=)
413 	(list 'remainder remainder)
414 	(list 'eq? eq?)
415 	(list 'equal? equal?)
416 	(list 'display display)))
417 (define (primitive-procedure-names)
418   (map car
419        primitive-procedures))
420 (define (primitive-procedure-objects)
421   (map (lambda (proc) (list 'primitive (cadr proc)))
422        primitive-procedures))
423 (define (apply-primitive-procedure proc args)
424   (apply-in-underlying-scheme
425    (primitive-implementation proc) args))
426 
427 ;; driver-loop
428 (define input-prompt ";;; M-Eval input:")
429 (define output-prompt ";;; M-Eval value:")
430 (define (driver-loop)
431   (prompt-for-input input-prompt)
432   (let ((input (read)))
433     (let ((output (eval input the-global-environment)))
434       (announce-output output-prompt)
435       (user-print output)))
436   (driver-loop))
437 (define (prompt-for-input string)
438   (newline) (newline) (display string) (newline))
439 
440 (define (announce-output string)
441   (newline) (display string) (newline))
442 (define (user-print object)
443   (if (compound-procedure? object)
444       (display (list 'compound-procedure
445                      (procedure-parameters object)
446                      (procedure-body object)
447                      '<procedure-env>))
448       (display object)))
449 (define (setup-environment)
450   (let ((initial-env
451          (extend-environment (primitive-procedure-names)
452                              (primitive-procedure-objects)
453                              the-empty-environment)))
454     (define-variable! 'true true initial-env)
455     (define-variable! 'false false initial-env)
456     initial-env))
457 (define the-global-environment (setup-environment))
458 
459 ;; auxiliary
460 (define (test-case actual expected)
461   (newline)
462   (display "Actual:   ")
463   (display actual)
464   (newline)
465   (display "Expected: ")
466   (display expected)
467   (newline))
468 (define (geval exp) ;; eval globally
469   (eval exp the-global-environment))
470 (define (test-eval exp expected)
471   (test-case (geval exp) expected))
472 
473 ;;  Exercise 4.16.  In this exercise we implement the method just described for interpreting internal definitions. We assume that the evaluator supports let (see exercise 4.6).
474 
475 ;; a.  Change lookup-variable-value (section 4.1.3) to signal an error if the value it finds is the symbol *unassigned*.
476 
477 ;; see above
478 
479 ;; b.  Write a procedure scan-out-defines that takes a procedure body and returns an equivalent one that has no internal definitions, by making the transformation described above.
480 
481 ;; (lambda <vars>
482 ;;   (define u <e1>)
483 ;;   (define v <e2>)
484 ;;   <e3>)
485 
486 ;; would be transformed into
487 
488 ;; (lambda <vars>
489 ;;   (let ((u '*unassigned*)
490 ;;         (v '*unassigned*))
491 ;;     (set! u <e1>)
492 ;;     (set! v <e2>)
493 ;;     <e3>))
494 
495 ;; (newline)
496 ;; (display "test")
497 ;; (newline)
498 
499 ;; (define (make-assignment var val)
500 ;;   (list 'set! var val))
501 
502 ;; (define (scan-out-defines body)
503 ;;   (define (scan-exps remaining-exps scanned-exps vars vals)
504 ;;     (if (null? remaining-exps)
505 ;; 	(make-let vars 
506 ;; 		  (map (lambda (var)
507 ;; 			 '*unassigned*)
508 ;; 		       vars)
509 ;; 		  (append 
510 ;; 		   (map (lambda (var val)
511 ;; 			  (make-assignment var val))
512 ;; 			vars 
513 ;; 			vals)
514 ;; 		   scanned-exps))
515 ;; 	(let ((first (car remaining-exps))
516 ;; 	      (rest (cdr remaining-exps)))
517 ;; 	  (if (definition? first)
518 ;; 	      (scan-exps rest
519 ;; 			 scanned-exps
520 ;; 			 (append vars (definition-variable first))
521 ;; 			 (append vals (definition-value first)))			 
522 ;; 	      (scan-exps rest
523 ;; 			 (append scanned-exps first)
524 ;; 			 vars
525 ;; 			 vals)))))
526 ;;   (scan-exps body '() '() '()))
527 ;; (filter definition? body)
528 ;; (remove definition? body)
529 
530 ;; (define (make-let vars vals body)
531 ;;   (cons 'let
532 ;; 	(cons (map list vars vals)
533 ;; 	      body)))
534 
535 
536 ;; c.  Install scan-out-defines in the interpreter, either in make-procedure or in procedure-body (see section 4.1.3). Which place is better? Why? 
537 
538 ;; better to put it in make-procedure. Otherwise, every time the procedure-body is requested for an application, we'd have to repeat the scanning. This would make applications quite slow and would be very inefficient.
539 
540 ;; scan-out-defines
541 
542 ;; (geval
543 ;;  '(define (f x)
544 ;;     (define (even? n)
545 ;;       (if (= n 0)
546 ;; 	  true
547 ;; 	  (odd? (- n 1))))
548 ;;     (define (odd? n)
549 ;;       (if (= n 0)
550 ;; 	  false
551 ;; 	  (even? (- n 1))))
552 ;;     (even? x)))
553 
554 ;; (test-eval '(f 5) false)
555 ;; (test-eval '(f 10) true)
556 
557 ;; (test-case
558 ;;  (scan-out-defines 
559 ;;   '((define (even? n)
560 ;;       (if (= n 0)
561 ;; 	  true
562 ;; 	  (odd? (- n 1))))
563 ;;     (define (odd? n)
564 ;;       (if (= n 0)
565 ;; 	  false
566 ;; 	  (even? (- n 1))))
567 ;;     (even? x)))
568 ;;  '(let ((even? '*unassigned*)
569 ;; 	(odd? '*unassigned*))
570 ;;     (set! even? 
571 ;; 	  (lambda (n) 
572 ;; 	    (if (= n 0)
573 ;; 		true
574 ;; 		(odd? (- n 1)))))
575 ;;     (set! odd? 
576 ;; 	  (lambda (n)
577 ;; 	    (if (= n 0)
578 ;; 		false
579 ;; 		(even? (- n 1)))))
580 ;;     (even? x)))
581 
582 ;; (geval
583 ;;  '(let ((x 5))
584 ;;     (define y x)
585 ;;     (define x 3)
586 ;;     (+ x y)))
587 ;; signal an error because x is undefined if variables are scanned out
588 
589 
590 
591 
592 
593 
594 ;; test-suite
595 
596 ;; procedure definitions
597 
598 (geval 
599  '(define (assoc key records)
600     (cond ((null? records) false)
601 	  ((equal? key (caar records)) (car records))
602 	  (else (assoc key (cdr records))))))
603 
604 (geval
605  '(define (map proc list)
606     (if (null? list)
607 	'()
608 	(cons (proc (car list))
609 	      (map proc (cdr list))))))
610 
611 (geval 
612  '(define (accumulate op initial sequence)
613     (if (null? sequence)
614 	initial
615 	(op (car sequence)
616 	    (accumulate op initial (cdr sequence))))))
617 
618 ;; all special forms
619 (test-eval '(begin 5 6) 6)
620 (test-eval '10 10)
621 (geval '(define x 3))
622 (test-eval 'x 3)
623 (test-eval '(set! x -25) 'ok)
624 (test-eval 'x -25)
625 (geval '(define z (lambda (x y) (+ x (* x y)))))
626 (test-eval '(z 3 4) 15)
627 (test-eval '(cond ((= x -2) 'x=-2)
628 		  ((= x -25) 'x=-25)
629 		  (else 'failed))
630 	   'x=-25)
631 (test-eval '(if true false true) false)
632 (test-eval 
633  '(let ((x 4) (y 7))
634     (+ x y (* x y)))
635  (+ 4 7 (* 4 7)))
636 
637 
638 ;; and/or
639 (geval '(define x (+ 3 8)))
640 (test-eval '(and 0 true x) 11)
641 (test-eval '(and 0 true x false) false)
642 (test-eval '(and 0 true x (set! x -2) false) false)
643 (test-eval 'x -2)
644 (test-eval '(and 0 true x false (set! x -5)) false)
645 (test-eval 'x -2)
646 (test-eval '(or false (set! x 25)) 'ok)
647 (test-eval 'x 25)
648 (test-eval '(or (set! x 2) (set! x 4)) 'ok)
649 (test-eval 'x 2)
650 (test-eval '(or false (set! x 25) true false) 'ok)
651 (test-eval 'x 25)
652 (test-eval '(or ((lambda (x) x) 5)) 5)
653 (test-eval '(or (begin (set! x (+ x 1)) x)) 26)
654 
655 
656 ;; cond
657 
658 (test-eval 
659  '(cond ((assoc 'b '((a 1) (b 2))) => cadr)
660 	(else false))
661  2)
662 
663 (test-eval
664  '(cond ((= 3 4) 'not-true)
665 	((= (* 2 4) 3) 'also-false)
666 	((map (lambda (x)
667 		(* x (+ x 1)))
668 	      '(2 4 1 9))
669 	 =>
670 	 (lambda (x)
671 	   (accumulate + 0 x)))
672 	(else 'never-reach))
673  118)
674 ;; '(6 20 2 90)
675 
676 
677 ;; procedure definition and application
678 (geval
679  '(define (factorial n)
680     (if (= n 0)
681 	1
682 	(* n (factorial (- n 1))))))
683 (test-eval '(factorial 5) 120)
684 
685 ;; map
686 
687 (test-eval
688  '(map (lambda (x)
689 	 (* x (+ x 1)))
690        '(2 1 4 2 8 3))
691  '(6 2 20 6 72 12))
692 ;; accumulate
693 
694 (test-eval
695  '(accumulate + 0 '(1 2 3 4 5))
696  15)
697 
698 ;; make-let
699 (test-eval 
700  (make-let '(x y) '(3 5) '((+ x y)))
701  8)
702 (test-eval 
703  '(let ()
704     5)
705  5)
706 (test-eval
707  '(let ((x 3))
708     x)
709  3)
710 (test-eval
711  '(let ((x 3)
712 	(y 5))
713     (+ x y))
714  8)
715 (test-eval 
716  '(let ((x 3)
717 	(y 2))
718     (+ (let ((x (+ y 2))
719 	     (y x))
720 	 (* x y))
721        x y))
722  (+ (* 4 3) 3 2))
723 (test-eval
724  '(let ((x 6)
725 	(y (let ((x 2))
726 	     (+ x 3)))
727 	(z (let ((a (* 3 2)))
728 	     (+ a 3))))
729     (+ x y z))
730  (+ 6 5 9))
731     
732 
733 ;; let*
734 
735 (test-eval
736  '(let* ((x 3)
737 	 (y (+ x 2))
738 	 (z (+ x y 5)))
739     (* x z))
740  39)
741 
742 (test-eval
743  '(let* ()
744     5)
745  5)
746 (test-eval
747  '(let* ((x 3))
748     (let* ((y 5))
749       (+ x y)))
750  8)
751 
752 (test-eval 
753  '(let* ((x 3)
754 	 (y (+ x 1)))
755     (+ (let* ((x (+ y 2))
756 	      (y x))
757 	 (* x y))
758        x y))
759  (+ (* 6 6) 3 4))
760 (test-eval
761  '(let* ((x 6)
762 	 (y (let* ((x 2)
763 		   (a (let* ((x (* 3 x)))
764 			(+ x 2))))       
765 	      (+ x a)))                  
766 	 (z (+ x y)))                    
767     (+ x y z))
768  32)
769 
770 ;; named-let
771 
772 (test-eval
773  '(let eight ()
774     5
775     7
776     8)
777  8)
778 (test-eval
779  '(let loop ((count 0))
780     (if (= 100 count)
781 	count
782 	(loop (+ count 1))))
783  100)
784 (geval
785  '(define (prime? x)
786     (let prime-iter ((i 2))
787       (cond ((> (* i i) x) true)
788 	    ((= (remainder x i) 0) false)
789 	    (else (prime-iter (+ i 1)))))))
790 (test-eval
791  '(let primes ((x 2)
792 	       (n 20))
793     (cond ((= n 0) '())
794 	  ((prime? x) 
795 	   (cons x
796 		 (primes (+ x 1) (- n 1))))
797 	  (else (primes (+ x 1) n))))
798  '(2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71))
799 
800 (geval
801  '(define (fib n)
802     (let fib-iter ((a 1)
803 		   (b 0)
804 		   (count n))
805       (if (= count 0)
806 	  b
807 	  (fib-iter (+ a b) a (- count 1))))))
808 (test-eval '(fib 19) 4181)
809 
810 ;; do-loop	  
811 (test-eval
812  '(let ((y 0))
813     (do ((x 0 (+ x 1)))
814 	((= x 5) y)
815       (set! y (+ y 1))))
816  5)
817 (test-eval
818  '(do ()
819       (true))
820  true)
821 (test-eval
822  '(do ()
823       (true 5))
824  5)
825 (test-eval
826  '(let ((y 0))
827     (do ()
828 	((= y 5) y)
829       (set! y (+ y 1))))
830  5)
831 
832 (test-eval
833  '(do ((y '(1 2 3 4)))
834       ((null? y))
835     (set! y (cdr y)))
836  true)
837 (test-eval
838  '(let ((y 0))
839     (do ((x 0 (+ x 1)))
840 	((= x 5) y)
841       (set! y (+ y 1))))
842  5)
843 (test-eval
844  '(let ((x '(1 3 5 7 9)))
845     (do ((x x (cdr x))
846 	 (sum 0 (+ sum (car x))))
847 	((null? x) sum)))
848  25)
849 (test-eval 
850  '(let ((z '()))
851     (do ((x '(1 2 3 4) (cdr x))
852 	 (y '(1 2 3 4 5 6 7 8) (cddr y)))
853 	((null? x) y x z)
854       (set! z (cons (car x) z))))
855  '(4 3 2 1))
856 
857 ;; make-unbound!
858 
859 (test-eval
860  '(let ((x 3))
861     (let ((x 5))
862       (make-unbound! x)
863       (* x x)))
864  9)
865 
866 (test-eval
867  '(let ((x 3))
868     (let ((x 5))
869       (define y x)
870       (make-unbound! x)
871       (* y x)))
872  15)
873 
874 (test-eval
875  '(let ((y -1) (x 3))
876     (let ((y 0.5) (x 5))
877       (define a x)
878       (define b y)
879       (make-unbound! x)
880       (make-unbound! y)
881       (* a b x y)))
882  (* 5 3 -1 0.5))
883 
884 (test-eval
885  '(let ((x 3) (y 4))
886     (let ((x 5))
887       (make-unbound! x)
888       (+ x 4)))
889  7)
890 
891 (test-eval 
892  '(let ((a 1) (b 2) (c 3) (d 4))
893     (make-unbound! b)
894     (+ a c d))
895  (+ 1 3 4))
896 
897 (test-eval
898  '(let ((x 4) (y 5))
899     (let ((a 1) (b 2) (c 3))
900       (let ((x (+ a b)) (y (+ c a)))
901 	(make-unbound! x)
902 	(let ((a x) (b (+ x y)))
903 	  (define z b)
904 	  (make-unbound! b)
905 	  (* (+ a z)
906 	     (+ a b y))))))
907  (* (+ 4 8)
908     (+ 4 2 4)))