anchor.diff:                                   included-structure-name included-slot-descriptions
                                    print-object print-function print-object-specializer
                                    named))
  +      ((or (eql type 'vector)
  +           (and (listp type)
  +                (eql (first type) 'vector)))
  +       (generate-vector-defstruct name slot-descriptions conc-name constructors predicate area copier
  +                                  included-structure-name included-slot-descriptions
  +                                  print-object print-function print-object-specializer
  +                                  named (if (listp type)
  +                                            (second type)
  +                                            't)))
         (t (error "Currently unsupported defstruct type ~S." type)))))
  
positive.code:                (unless (or (eql type 'list) (eql type 'vector)
                             (and (consp type)
                                  (eql (first type) 'vector)
                                  (= (length type) 2)
                                  (or (and (integerp (second type))
                                           (<= 0 (second type) array-dimension-limit))
                                      (eql (second type) '*))))
                   (error "Invalid :TYPE option ~S.%" option)))
  	      (t (error "Unsupported DEFSTRUCT option ~S" option))))))
      (values name
  
negative.code:                                (third s)
                                 (first s)))
                           slots))))))
  
  (defun generate-simple-defstruct-vector-constructor (leader-name slots name area)
    `(defun ,name (&key ,@(mapcar (lambda (slot)
                                    (list (first slot) (third slot)))
                                  slots))
       (vector ,@(when leader-name (list `',leader-name))
               ,@(mapcar 'first slots))))
  
  (defun generate-defstruct-vector-constructor (leader-name slots name lambda-list area)
    (multiple-value-bind (required optional rest enable-keys keys allow-other-keys aux)
        (parse-ordinary-lambda-list lambda-list)
      (declare (ignore enable-keys allow-other-keys))
      ;; Pick out the slot names and compute the slots without a lambda variable
      (let* ((assigned-slots (append required
  				   (mapcar #'first optional)
  				   (remove 'nil (mapcar #'third optional))
  				   (when rest (list rest))
  				   (mapcar #'cadar keys)
  				   (remove 'nil (mapcar #'third keys))
  				   (mapcar #'first aux)))
  	   (default-slots (set-difference (mapcar #'first slots) assigned-slots)))
        `(defun ,name ,lambda-list
           (vector ,@(when leader-name (list `',leader-name))
                   ,@(mapcar (lambda (s)
                               (if (member (first s) default-slots)
                                   (third s)
                                   (first s)))
                             slots))))))
  
  (defun compute-defstruct-slots (conc-name slot-descriptions included-structure included-slot-descriptions)
    (when included-slot-descriptions
  