anchor.diff:  (defmethod show-object ((h handler))
     (show-object (.handler-class h)))
   
  -(defun make-handler ((handler-class class) (handler-function function)
  +(defun make-handler ((c class) (f function)
                        &optional (associated-condition nil))
  -  (let ((h (make handler)))
  -    (setf (.handler-class h) handler-class)
  -    (setf (.handler-function h) handler-function)
  -    (setf (.associated-condition h) associated-condition)
  -    h))
  +  (make handler
  +        :handler-class c
  +        :handler-function f
  +        :associated-condition associated-condition))
   
   (defclass handler-frame ()
     (handlers
      parent-frame))
   
   (defun make-handler-frame ((handlers list) &optional (parent-frame nil))
  -  (let ((f (make handler-frame)))
  -    (setf (.handlers f) handlers)
  -    (setf (.parent-frame f) parent-frame)
  -    f))
  +  (make handler-frame :handlers handlers :parent-frame parent-frame))
   
   (defdynamic handler-frame)
   
  
positive.code:    max))
  
  (defun make-number-iter (max)
    (let ((iter (make number-iter)))
      (setf (.i iter) 0)
      (setf (.max iter) max)
      iter))
  
  (defmethod iter ((max number))
    (make-number-iter max))
  
negative.code:    i))
  
  (defun list-iter ((list list))
    (make list-iter :list list :i 0))
  
  (defmethod has-next ((iter list-iter))
    (< (.i iter) (len (.list iter))))
  