anchor.diff:    (: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
  +(defun print-constructor (object stream fields)
  +  (let* ((prefix
              ;; "If `*read-eval*' is false and `*print-readably*' is
              ;; true, any method for `print-object' that would output a
              ;; reference to the `#.' reader macro either outputs
  
positive.code:             (:print-function
               (lambda (object stream depth)
                 (declare (ignore depth))
                 (print-constructor object stream))))
           ,@(unsplice docstring)
           ,@(loop for (slot-name slot-type) in slots
                   collect `(,slot-name :type ,slot-type)))
  
negative.code:                ,@(loop for reader in readers
                         collect `(,reader self))))
  
         ;; Define a comparison method.
         (defmethod %constructor= ((o1 ,type-name) (o2 ,type-name))
           (and ,@(loop for reader in readers
                        collect `(constructor= (,reader o1)
                                               (,reader o2)))))
  
         (trivia:defpattern ,type-name (&optional ,@slot-names)
           (list
  