anchor.diff:                         (generate-defstruct-list-constructor (when named name) slots (first x) (second x) area)))
                    constructors)
          ',name)))
  +
  +(defun 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 inner-type)
  +  (when (and named (not (eql inner-type 't)))
  +    (error "Named VECTOR struct with non-T type."))
  +  (when (or included-structure-name included-slot-descriptions)
  +    (error "Included VECTOR structures not supported yet."))
  +  (when (and predicate (not named))
  +    (error "Predicate with unnamed VECTOR structure."))
  +  (when (or print-object print-function print-object-specializer)
  +    (error "PRINT-OBJECT and PRINT-FUNCTION with VECTOR structure not supported yet."))
  +  (let ((slots (compute-defstruct-slots conc-name
  +                                        slot-descriptions
  +                                        nil
  +                                        included-slot-descriptions)))
  +    `(progn
  +       ,@(when predicate
  +           (list `(defun ,predicate (object)
  +                    (and (vectorp object)
  +                         (eql (aref object 0) ',name)))))
  +       ,@(when copier
  +           (list `(defun ,copier (object)
  +                    (make-array (length object)
  +                                :element-type ',inner-type
  +                                :initial-contents object))))
  +       ,@(let ((n (if named 0 -1)))
  +           (mapcar (lambda (s)
  +                     (incf n)
  +                     `(progn
  +                        (defun ,(second 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)
  +                                     ,@(when (and named predicate)
  +                                         (list `(check-type object (satisfies ,predicate))))
  +                                     (setf (aref object ,n) (the ,(fourth s) new-value)))))))
  +                   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)))
  +                 constructors)
  +       ',name)))
   )
   
   (defun structure-type-p (object struct-type)
  
positive.code:                                (third s)
                                 (first s)))
                           slots))))))
  
  (defun compute-defstruct-slots (conc-name slot-descriptions included-structure included-slot-descriptions)
    (when included-slot-descriptions
  
negative.code:                (unless (or (eql type 'list) (eql type 'vector)
                             (and (consp type)
                                  (eql (first type) 'vector)
                                  (= (length type) 2)))
                   (error "Invalid :TYPE option ~S.%" option)))
  	      (t (error "Unsupported DEFSTRUCT option ~S" option))))))
      (values name
  