anchor.diff:                                                                        (list `#',(cat-symbol '#:marshall-
                                                                                               (slot-marshall-type s)))
                                                                         '()))))
  -                                (if (slot-optional-p (slot-symbol s) optional-slots :write)
  +                                (if (slot-optional-p s :write)
                                       `(when (,(accessor (slot-symbol s)) obj)
                                          ,encode-form)
                                       encode-form)))))))))
  
positive.code:          (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 cell
                                           (error 'invalid-json-obj :type ',name :json json-obj))))
                             (when cell
  
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)
  