anchor.diff:       ,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
  
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.
  