anchor.diff:                (t copier-name))
               included-structure-name included-slot-descriptions
               print-object print-function print-object-specializer
  -            named type)))
  +            named type slot-offsets)))
   
   ;; Parses slot-description and produces:
   ;; (slot-name accessor-name initform type read-only)
  
positive.code:        (eval-when (:compile-toplevel :load-toplevel :execute)
           (%defstruct ',struct-type))
         ,@(when predicate
                 (list `(defun ,predicate (object)
                          (structure-type-p object ',struct-type))))
         ,@(when copier
                 (list `(defun ,copier (object)
                          (check-type object ,name)
                          (copy-structure object))))
         ,@(when print-object
                 (list `(defmethod print-object ((object ,name) stream)
                          (funcall (function ,print-object) object stream))))
         ,@(when print-function
                 (list `(defmethod print-object ((object ,name) stream)
                          (funcall (function ,print-function) object stream 0))))
         ,@(let ((n 0))
                (mapcar (lambda (s)
                          (setf n (1+ n))
                          `(progn
                             (declaim (inline ,(structure-slot-accessor s)))
                             (defun ,(structure-slot-accessor s) (object)
                               (check-struct-type object ',struct-type)
                               (the ,(structure-slot-type s) (%struct-slot (the ,name object) ,n)))
                             ,@(unless (structure-slot-read-only s)
                                       (list `(declaim (inline (setf ,(structure-slot-accessor s))))
                                             `(defun (setf ,(structure-slot-accessor s)) (new-value object)
                                                (check-struct-type object ',struct-type)
                                                (setf (%struct-slot (the ,name object) ,n)
                                                      (the ,(structure-slot-type s) new-value)))
                                             `(declaim (inline (cas ,(structure-slot-accessor s))))
                                             `(defun (cas ,(structure-slot-accessor s)) (old new object)
                                                (check-struct-type object ',struct-type)
                                                (cas (%struct-slot (the ,name object) ,n)
                                                     (the ,(structure-slot-type s) old)
                                                     (the ,(structure-slot-type s) new)))))))
                        slots))
         ,@(mapcar (lambda (x)
                     (if (symbolp x)
                         (generate-simple-defstruct-constructor struct-type x area)
                         (generate-defstruct-constructor struct-type (first x) (second x) area)))
                   constructors)
         ',name)))
  
  (defun generate-list-defstruct (name slot-descriptions conc-name constructors predicate area copier
                                  included-structure-name included-slot-descriptions
                                  print-object print-function print-object-specializer
                                  named)
    (when (or included-structure-name included-slot-descriptions)
      (error "Included LIST structures not supported yet."))
    (when (and predicate (not named))
  
negative.code:                                 (eql (first type) 'vector)
                                  (= (length type) 2)))
                   (error "Invalid :TYPE option ~S.%" option)))
                ;; :slot-offsets
                ((eql option :slot-offsets)
                 (setf slot-offsets t))
                (t (error "Unsupported DEFSTRUCT option ~S" option))))))
      (values name
              (if conc-namep
  