anchor.diff:      (iter (frame-vars frame) (frame-vals frame))))
   
   (defun t-eval (exp env)
  -  (format t "t-eval: ~a~%" exp)
  +  (funcall (analyze exp) env))
  +
  +(defun analyze (exp)
  +  (format t "analyze: ~a~%" exp)
     (cond
  -    ((self-evaluating-p exp) exp)
  -    ((variable-p exp) (env-get env exp))
  -    ((quoted-p exp) (object-of-quoted exp))
  -    ((assignment-p exp) (eval-assignment exp env))
  -    ((definition-p exp) (eval-definition exp env))
  -    ((lambda-p exp) (eval-lambda exp env))
  -    ((if-p exp) (eval-if exp env))
  -    ((cond-p exp) (t-eval (cond->if exp) env))
  -    ((and-p exp) (eval-and exp env))
  -    ((or-p exp) (eval-or exp env))
  -    ((let-p exp) (t-eval (let->combination exp) env))
  -    ((let*-p exp) (t-eval (let*->nested-let exp) env))
  -    ((begin-p exp) (eval-sequence (begin-actions exp) env))
  -    ((application-p exp) (eval-application exp env))
  +    ((self-evaluating-p exp) (analyze-self-evaluating exp))
  +    ((variable-p exp) (analyze-variable exp))
  +    ((quoted-p exp) (analyze-quoted exp))
  +    ((assignment-p exp) (analyze-assignment exp))
  +    ((definition-p exp) (analyze-definiton exp))
  +    ((lambda-p exp) (analyze-lambda exp))
  +    ((if-p exp) (analyze-if exp))
  +    ((cond-p exp) (analyze (cond->if exp)))
  +    ((and-p exp) (analyze-and exp))
  +    ((or-p exp) (analyze-or exp))
  +    ((let-p exp) (analyze (let->combination exp)))
  +    ((let*-p exp) (analyze (let*->nested-let exp)))
  +    ((begin-p exp) (analyze-sequence (begin-actions exp)))
  +    ((application-p exp) (analyze-application exp))
       (t 'not-implemented)))
  +
  +(defun analyze-self-evaluating (exp)
  +  (lambda (env) exp))
  +
  +(defun analyze-variable (exp)
  +  (lambda (env) (env-get env exp)))
  +
  +(defun analyze-quoted (exp)
  +  (let ((qval (object-of-quoted exp)))
  +    (lambda (env) qval)))
  +
  +(defun analyze-assignment (exp)
  +  (let ((var (assignment-var exp))
  +	(val-proc (analyze (assignment-val exp))))
  +    (lambda (env)
  +     (set-variable-value! env var (funcall val-proc env))
  +     'ok)))
  +
  +(defun analyze-definiton (exp)
  +  (let ((var (definition-var exp))
  +	(val-proc (analyze (definition-val exp))))
  +    (lambda (env)
  +      (define-variable!
  +	  (env-first-frame env)
  +	  var (funcall val-proc env))
  +      'ok)))
  +
  +(defun analyze-if (exp)
  +  (let ((pred-proc (analyze (if-predicate exp)))
  +	(consequent-proc (analyze (if-consequent exp)))
  +	(alternative-proc (analyze (if-alternative exp))))
  +    (lambda (env)
  +      (if (true-p (funcall pred-proc env))
  +	  (funcall consequent-proc env)
  +	  (funcall alternative-proc env)))))
   
   (defun self-evaluating-p (exp)
     (or (numberp exp)
  
positive.code: 
  (defun false-p (exp)
    (eq exp 'false))
  
  (defun eval-if (exp env)
    (if (true-p (t-eval (if-predicate exp) env))
        (t-eval (if-consequent exp) env)
        (t-eval (if-alternative exp) env)))
  
  (defun cond-p (exp)
    (tagged-list-p exp 'cond))
  
negative.code: 
  (defun apply-compound-procedure (procedure args)
    (let ((vars (procedure-parameters procedure))
  	(body-proc (procedure-body-proc procedure))
  	(env (procedure-env procedure)))
      (let ((extended-env (env-extend env vars args)))
        (format t "apply-cp vars: ~a~%" vars)
        (format t "apply-cp args: ~a~%" args)
        (format t "apply-cp body: ~a~%" body-proc)
        (format t "apply-cp env: ~a~%" extended-env)
        (funcall body-proc extended-env))))
  
  (defun to-boolean (exp)
    (if (null exp)
  