anchor.diff:  	       nil)
   	      ;; Default predicate.
   	      ((eq predicate-name 't)
  -	       (concat-symbols name '-p))
  +               (when (or (null type) named)
  +                 (concat-symbols name '-p)))
   	      ;; Explicit predicate.
   	      (t predicate-name))
               area
  
positive.code: 	      ;; Explicit copier.
  	      (t copier-name))
              included-structure-name included-slot-descriptions
              print-object print-function print-object-specializer)))
  
  ;; Parses slot-description and produces:
  ;; (slot-name accessor-name initform type read-only)
  
negative.code: 	   (default-slots (set-difference (mapcar #'first (structure-slots struct-type)) assigned-slots))
  	   (tmp (gensym)))
        `(defun ,name ,lambda-list
           (let ((,tmp (%make-struct ,(1+ (length (structure-slots struct-type))) ',area)))
             (setf (%struct-slot ,tmp 0) ',struct-type)
             ,@(let ((n 0))
                    (mapcar (lambda (s)
                              (setf n (1+ n))
                              `(setf (%struct-slot ,tmp ,n) ,(if (member (first s) default-slots)
                                                                 (third s)
                                                                 (first s))))
                            (structure-slots struct-type)))
             ,tmp)))))
  
  (defun generate-simple-defstruct-list-constructor (leader-name slots name area)
    `(defun ,name (&key ,@(mapcar (lambda (slot)
                                    (list (first slot) (third slot)))
                                  slots))
       (list ,@(when leader-name (list `',leader-name))
             ,@(mapcar 'first 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)
        (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
           (list ,@(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
  