anchor.diff:           (let ((arglist '()))
              ,@(loop for s in serialized-slots
                   collect `(let ((cell (assoc (json-key ',(slot-symbol s)) json-obj)))
  -                           ,@(unless (slot-optional-p (slot-symbol s) optional-slots :read)
  +                           ,@(unless (slot-optional-p s :read)
                                        `((unless cell
                                            (error 'invalid-json-obj :type ',name :json json-obj))))
                              (when cell
  
positive.code:                                                                       (list `#',(cat-symbol '#:marshall-
                                                                                              (slot-marshall-type s)))
                                                                        '()))))
                                  (if (slot-optional-p (slot-symbol s) optional-slots :write)
                                      `(when (,(accessor (slot-symbol s)) obj)
                                         ,encode-form)
                                      encode-form)))))))))
  
negative.code:   (intern (format nil "~{~A~}" (mapcar #'symbol-name
                                         (cons symbol rest)))))
  
    (defun slot-optional-p (slot type)
      (check-type type symbol)
      (let ((optional-type (optional-slot-p slot)))
        (ecase type
          (:write (ecase optional-type
                    ((:write :read-write) t)
                    ((:read nil) nil)))
          (:read (ecase optional-type
                   ((:read :read-write) t)
                   ((:write nil) nil)))
          ((nil) (ecase optional-type
                   ((nil) t)
                   ((:read :write :read-write) nil)))))))
  
  (define-condition invalid-json-obj (error)
    ((type :initarg :type :accessor obj-type)
  