anchor.diff:                            :object object))
                  "("))
            (list (cons (type-of object) fields)))
  -    (declare (dynamic-extent fields list))
       (pprint-logical-block (stream
                              list
                              :prefix prefix
  
positive.code:             (:print-function
               (lambda (object stream depth)
                 (declare (ignore depth))
                 (print-constructor object stream
                                    ,@(loop for reader in readers
                                            collect `(function ,reader))))))
           ,@(unsplice docstring)
           ,@(loop for (slot-name slot-type) in slots
                   collect `(,slot-name :type ,slot-type)))
  
negative.code:      ',var))
  
  ;;; TODO Is this worth exporting?
  (defun constructor= (x y)
    (or (equal x y)
        (%constructor= x y)))
  
  (defgeneric %constructor= (x y)
    (:method (x y)
      (equal x y)))
  
  ;;; How about these?
  (defun constructor-ref (x idx)
    (check-type idx array-index)
    (%constructor-ref x idx))
  
  (defgeneric %constructor-ref (x idx)
    (:method (x (idx integer))
      (error "Illegal index for ~a" x)))
  
  (defun constructor-len (x)
    (assure array-length
      (%constructor-len x)))
  
  (defgeneric %constructor-len (x))
  
  (defun constructor-fields (object)
    (loop for i below (constructor-len object)
          collect (constructor-ref object i)))
  
  (defun print-constructor (object stream)
    (let* ((fields (constructor-fields object))
           (prefix
             ;; "If `*read-eval*' is false and `*print-readably*' is
             ;; true, any method for `print-object' that would output a
  