anchor.diff:              (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)))))))
  +          (let* ((slot-defs (mapcar #'read-only-slotdef slots))
  +                 (slot-names (mapcar #'first slot-defs)))
  +            `(progn
  +               (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)
  +                 ,@slot-defs)
  +               (defmethod read-only-struct-slot-names append ((self ,name))
  +                 ',slot-names)
  +               ',name)))))))
   
   (defmacro defvar-unbound (var &body (docstring))
     "Define VAR as if by `defvar' with no init form, and set DOCSTRING
  
positive.code: 
  The idea here is simply that an unbound slot in an immutable data
  structure does not make sense.
  
  On Lisps that support it, the structure is also marked as \"pure\":
  that is, instances may be moved into read-only memory.
  
negative.code:      ,slots
       ,@options))
  
  (defgeneric read-only-struct-slot-names (x)
    (:method append ((x t)) nil)
    (:method-combination append))
  
  (defstruct
      (%read-only-struct
       (:constructor nil)                 ;Abstract.
       (:copier nil)
       (:predicate nil))
    "Abstract base class for read-only structures.")
  
  (defmethod make-load-form ((self %read-only-struct) &optional env)
    (let* ((slot-names (read-only-struct-slot-names self))
           (slot-names (remove-duplicates slot-names)))
      (make-load-form-saving-slots self
                                   :slot-names slot-names
                                   :environment env)))
  
  (defun read-only-include-clause (clause)
    "Rewrite CLAUSE, an include clause, for use with a read-only
  