anchor.diff:  
   (defgeneric describe-object (object stream))
   
  +(defgeneric describe-object-self (object stream))
  +
  +(defgeneric describe-object-type (object stream))
  +
   ;;; For these methods, stream should be of type
   ;;; (or EXTENDED-OUTPUT-STREAM OUTPUT-RECORDING-STREAM)
   ;;; but CLIM-STREAM-PANE is used instead.
  
positive.code: (clim-internals::with-system-redefinition-allowed
      (defmethod describe-object ((object t) stream)
        (let ((*print-array* nil))
          (clim:present object (clim:presentation-type-of object)
                        :stream stream)
          (format stream " is of type ")
          (clim:present (type-of object) (clim:presentation-type-of (type-of object))
                        :stream stream)
          (terpri stream))))
  
  (defmethod describe-object ((object symbol) stream)
    (clim:present object (clim:presentation-type-of object)
                  :stream stream)
    (format stream " is of type ")
    (clim:present (type-of object) (clim:presentation-type-of (type-of object))
                  :stream stream)
    (terpri stream)
    (cond
     ((not (boundp object))
      (format stream "   it is unbound~%"))
     (t
      (format stream "   it has a value of ")
      (clim:present (symbol-value object) (clim:presentation-type-of (symbol-value object))
                    :stream stream)
      (terpri)))
    (format stream "   it is in the ")
    (clim:present (symbol-package object) (clim:presentation-type-of (symbol-package object))
                  :stream stream)
    (format stream " package~%")
    (when (fboundp object)
      (format stream "   it has a function definition of ~S~%" (symbol-function object))
  
negative.code:                    #+clisp (ext:arglist (symbol-function object))
                     #-(or excl cmu sbcl clisp) "( ??? )"))
        (when arglist
          (present-simply arglist stream)))
      (terpri))
    (format stream "   it has a property list of ~S~%" (symbol-plist object)))
  
  (defmethod describe-object-self ((object symbol) stream)
    (present-simply object stream))
  
  (defmethod describe-object ((object number) stream)
    (standard-describe-object-header object stream :kind "a number"))
  
  (defmethod describe-object ((object string) stream)
    (standard-describe-object-header
     object stream :suffix (lambda (stream)
                             (format stream " with a length of ")
                             (present-simply (length object) stream 'clim:integer))))
  
  (defmethod describe-object ((object package) stream)
    (standard-describe-object-header
     object stream :suffix (lambda (stream)
                             (format stream " its name is ")
                             (present-simply (package-name object) stream)))
    (format stream "   it has the nicknames of ")
    (clim:present (package-nicknames object) 'clim:expression :stream stream)
    (terpri stream)
    (format stream "   it uses these packages: ")
    (clim:present (package-use-list object) 'clim:expression :stream stream)
    (terpri stream)
    (format stream "   it is used by the packages: ")
    (clim:present (package-used-by-list object) 'clim:expression :stream stream)
    (terpri stream))
  
  (labels ((present-slot/text (slot object stream width)
             (let ((name (c2mop:slot-definition-name slot)))
               (cond
                 ((slot-boundp object name)
                  (format stream "      ~v@A: " width name)
                  (clim:present (slot-value object name) 'clim:expression :stream stream)
                  (terpri stream))
                 (t
                  (format stream "      ~v@A: <unbound>~%" width name)))))
  
           (present-instance-slots/text (object stream)
             (let* ((slots (c2mop:class-slots (class-of object)))
                    (width (loop for slot in slots
                              maximizing (length (symbol-name (c2mop:slot-definition-name slot))))))
               (map nil (alexandria:rcurry #'present-slot/text object stream width) slots)))
  
           (present-slot/table (slot object stream)
             (let ((name (c2mop:slot-definition-name slot)))
               (clim:formatting-row (stream)
                 (clim:formatting-cell (stream :align-x :right)
                   (present-simply name stream)
                   (write-char #\: stream))
                 (clim:formatting-cell (stream)
                   (if (slot-boundp object name)
                       (clim:present (slot-value object name) 'clim:expression
                                     :stream stream)
                       (format stream "<unbound>"))))))
  
           (present-instance-slots/table (object stream)
             (let ((slots (c2mop:class-slots (class-of object))))
               (clim:formatting-table (stream)
                 (map nil (alexandria:rcurry #'present-slot/table object stream) slots))))
  
           (describe-instance (object stream kind)
             (standard-describe-object-header object stream :kind kind)
             (format stream "   it has the following slots:~%")
             (if (typep stream 'clim:output-recording-stream)
                 (present-instance-slots/table object stream)
                 (present-instance-slots/text object stream))))
  
    (defmethod describe-object ((object standard-object) stream)
      (describe-instance object stream "an instance"))
  
    (defmethod describe-object ((object structure-object) stream)
      (describe-instance object stream "a structure")))
  