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: (defmethod default-handler ((c serious-condition))
    (invoke-debugger c))
  (defmethod default-handler ((r restart))
    (let ((e (make restart-control-error)))
      (setf (.restart e) r)
      (error e)))
  
  (defclass handler ()
    (handler-class
  
negative.code:   (name
     namespace))
  (defun make-unbound-variable ((name string) (namespace string))
    (make unbound-variable :name name :namespace namespace))
  (defmethod show ((e unbound-variable))
    (string-concat "The " (.namespace e) " " (.name e) " is unbound."))
  (defclass simple-error (error))
  