anchor.diff:  (defun rest-exps (exps)
     (cdr exps))
   
  -(defun eval-sequence (exps env)
  -  (if (last-exp-p exps)
  -     (t-eval (first-exp exps) env)
  -     (progn
  -       (t-eval (first-exp exps) env)
  -       (eval-sequence (rest-exps exps) env))))
  +(defun analyze-sequence (exps)
  +  (labels
  +      ((sequentially (proc1 proc2)
  +	 (lambda (env) (funcall proc1 env) (funcall proc2 env)))
  +       (iter (first-proc rest-procs)
  +	 (if (last-exp-p rest-procs)
  +	     first-proc
  +	     (iter (sequentially first-proc (car rest-procs))
  +		   (cdr rest-procs)))))
  +    (let ((procs (mapcar #'analyze exps)))
  +      (if (null procs)
  +	  (error "empty sequence")
  +	  (iter (car procs) (cdr procs))))))
   
   (defun application-p (exp)
     (consp 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 application-operand (exp)
    (cdr exp))
  
  (defun analyze-application (exp)
    (let ((procedure-proc (analyze (application-operator exp)))
  	(arg-procs (list-of-value-procs (application-operand exp))))
      (lambda (env)
        (t-apply
         (funcall procedure-proc env)
         (mapcar #'(lambda (proc) (funcall proc env)) arg-procs)))))
  
  (defun list-of-value-procs (args)
    (mapcar #'analyze args))
  
  (defun primitive-procedure-p (exp)
    (tagged-list-p exp 'primitive))
  