anchor.diff:             (mapcar (lambda (s)
                        (incf n)
                        `(progn
  -                        (defun ,(second s) (object)
  +                        (defun ,(structure-slot-accessor s) (object)
                             ,@(when (and named predicate)
                                 (list `(check-type object (satisfies ,predicate))))
                             (aref object ,n))
  -                        ,@(unless (fifth s)
  -                            (list `(defun (setf ,(second s)) (new-value object)
  +                        ,@(unless (structure-slot-read-only s)
  +                            (list `(defun (setf ,(structure-slot-accessor s)) (new-value object)
                                        ,@(when (and named predicate)
                                            (list `(check-type object (satisfies ,predicate))))
  -                                     (setf (aref object ,n) (the ,(fourth s) new-value)))
  -                                  `(defun (cas ,(second s)) (old new object)
  +                                     (setf (aref object ,n) (the ,(structure-slot-type s) new-value)))
  +                                  `(defun (cas ,(structure-slot-accessor s)) (old new object)
                                        ,@(when (and named predicate)
                                            (list `(check-type object (satisfies ,predicate))))
  -                                     (cas (aref object ,n) (the ,(fourth s) old) (the ,(fourth s) new)))))))
  +                                     (cas (aref object ,n) (the ,(structure-slot-type s) old) (the ,(structure-slot-type s) new)))))))
                      slots))
          ,@(mapcar (lambda (x)
                      (if (symbolp x)
  
positive.code:            (mapcar (lambda (s)
                       (incf n)
                       `(progn
                          (defun ,(second s) (object)
                            ,@(when (and named predicate)
                                (list `(check-type object (satisfies ,predicate))))
                            (nth ,n object))
                          ,@(unless (fifth s)
                              (list `(defun (setf ,(second s)) (new-value object)
                                       ,@(when (and named predicate)
                                           (list `(check-type object (satisfies ,predicate))))
                                       (setf (nth ,n object) (the ,(fourth s) new-value)))))))
                     slots))
         ,@(mapcar (lambda (x)
                     (if (symbolp x)
  
negative.code: 
  (defun generate-simple-defstruct-list-constructor (leader-name slots name area)
    `(defun ,name (&key ,@(mapcar (lambda (slot)
                                    (list (structure-slot-name slot) (structure-slot-initform slot)))
                                  slots))
       (list ,@(when leader-name (list `',leader-name))
             ,@(mapcar #'structure-slot-name slots))))
  
  (defun generate-defstruct-list-constructor (leader-name slots name lambda-list area)
    (multiple-value-bind (required optional rest enable-keys keys allow-other-keys aux)
  