anchor.diff:                          (defun ,(structure-slot-definition-accessor s) (object)
                             ,@(when (and named predicate)
                                 (list `(check-type object (satisfies ,predicate))))
  -                          (svref object ,n))
  +                          (the ,(structure-slot-definition-type s)
  +                               (,access-fn object ,n)))
                           ,@(unless (structure-slot-definition-read-only s)
                               (list `(declaim (inline (setf ,(structure-slot-definition-accessor s))))
                                     `(defun (setf ,(structure-slot-definition-accessor s)) (new-value object)
                                        ,@(when (and named predicate)
                                            (list `(check-type object (satisfies ,predicate))))
  -                                     (setf (svref object ,n) (the ,(structure-slot-definition-type s) new-value)))
  +                                     (the ,(structure-slot-definition-type s)
  +                                          (setf (,access-fn object ,n) (the ,(structure-slot-definition-type s) new-value))))
                                     `(declaim (inline (cas ,(structure-slot-definition-accessor s))))
                                     `(defun (cas ,(structure-slot-definition-accessor s)) (old new object)
                                        ,@(when (and named predicate)
                                            (list `(check-type object (satisfies ,predicate))))
  -                                     (cas (svref object ,n) (the ,(structure-slot-definition-type s) old) (the ,(structure-slot-definition-type s) new)))))))
  +                                     (the ,(structure-slot-definition-type s)
  +                                          (cas (,access-fn object ,n)
  +                                               (the ,(structure-slot-definition-type s) old)
  +                                               (the ,(structure-slot-definition-type s) new))))))))
                      slots))
          ,@(mapcar (lambda (x)
                      (if (symbolp x)
  -                       (generate-simple-defstruct-vector-constructor (when named name) slots x area)
  -                       (generate-defstruct-vector-constructor (when named name) slots (first x) (second x) area)))
  +                       (generate-simple-defstruct-vector-constructor (when named name) slots x area inner-type)
  +                       (generate-defstruct-vector-constructor (when named name) slots (first x) (second x) area inner-type)))
                    constructors)
          ',name)))
   )
  
positive.code:   (let ((slots (compute-defstruct-slots conc-name
                                          slot-descriptions
                                          nil
                                          included-slot-descriptions)))
      `(progn
         ,@(when predicate
             (list `(defun ,predicate (object)
  
negative.code:        for s in (append included-slots
                          slot-descriptions)
         collect (multiple-value-bind (def slot-index next-index boxedp)
                     (parse-defstruct-slot conc-name s current-index default-slot-type)
                   (adjust-array layout (truncate (+ next-index 7) 8) :initial-element 0)
                   (when boxedp
                     (dotimes (i (ceiling (- next-index slot-index) 8))
  