anchor.diff:  ;;; 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.
  +;;; definition, there is nothing to prevent the superclass (or any
  +;;; other class in the inheritance chain) from being redefined with
  +;;; mutable slots in the future.
   
   (defmacro defstruct-read-only (name-and-opts &body slots)
     "Easily define a defstruct with no mutable slots.
  
positive.code:             (if-let (clause (find :include opts :key #'car-safe))
                (values clause (remove clause opts))
                (values nil opts))
            `(defstruct (,name (:copier nil)
                               ;; Mark as OK to save in pure memory.
                               #+(or sbcl cmucl) (:pure t)
                               ,@opts
                               ,(read-only-include-clause include-clause))
               ,@(unsplice docstring)
               ,@(mapcar #'read-only-slotdef slots)))))))
  
  (defmacro defvar-unbound (var &body (docstring))
    "Define VAR as if by `defvar' with no init form, and set DOCSTRING
  
negative.code: 
  The idea here is simply that an unbound slot in an immutable data
  structure does not make sense.
  
  A read-only struct is always externalizable; it has an implicit
  definition for `make-load-form'.
  
  On Lisps that support it, the structure is also marked as \"pure\":
  that is, instances may be moved into read-only memory.
  