anchor.diff:      ((list)
        `(:include %read-only-struct))
       ((list* :include type slot-redefs)
  +     ;; Do we need to specify that the slots are read-only? No, since
  +     ;; we can only inherit from read-only structures, and the
  +     ;; specification says that read-only slots cannot be redefined as
  +     ;; mutable by their heirs. However, we still need to process the
  +     ;; slots, so we can support skipping the initform to supply a
  +     ;; `:type' option (which, of course, must be a subtype of the
  +     ;; slot's type in the parent).
        `(:include ,type
                   ,@(mapcar #'read-only-slotdef slot-redefs)))))
   
  
positive.code:   (flet ((car-safe (x) (if (consp x) (car x) nil)))
      (let ((docstring (and (stringp (first slots)) (pop slots))))
        (destructuring-bind (name . opts) (ensure-list name-and-opts)
          (when (find :copier opts :key #'ensure-car)
            (error "Read only struct ~a does not need a copier."
                   name))
  
negative.code:             :read-only t
              ,@args))))))
  
  ;;; Why not allow `defstruct-read-only' to use inheritance? I would
  ;;; like to, but I haven't figured out yet how to make it work
  ;;; reliably. The point of `defstruct-read-only' is that when you see
  ;;; it you know *for sure* that the instances are immutable -- that
  ;;; all the slots are read-only. But where there is inheritance, there
  ;;; are no guarantees. Even if we could check that the class being
  ;;; inherited from has only read-only slots at the time the initial
  ;;; definition, there is nothing to prevent the superclass from being
  ;;; redefined in the future.
  
  (defmacro defstruct-read-only (name-and-opts &body slots)
    "Easily define a defstruct with no mutable slots.
  
  The syntax of `defstruct-read-only' is as close as possible to that of
  