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:   (intern (format nil "~{~A~}" (mapcar #'symbol-name
                                         (cons symbol rest)))))
  
    (defun slot-optional-p (symbol optional-slots type)
      (check-type symbol symbol)
      (check-type optional-slots list)
      (check-type type keyword)
      (let ((cell (assoc symbol optional-slots)))
        (and cell
             (ecase type
               (:write
                (or (eq (cdr cell) :write)
                    (eq (cdr cell) :read-write)))
               (:read
                (or (eq (cdr cell) :read)
                    (eq (cdr cell) :read-write)))
               (:read-write (eq (cdr cell) :read-write)))))))
  
  (define-condition invalid-json-obj (error)
    ((type :initarg :type :accessor obj-type)
  
negative.code:                                                                       (list `#',(cat-symbol '#:marshall-
                                                                                              (slot-marshall-type s)))
                                                                        '()))))
                                  (if (slot-optional-p s :write)
                                      `(when (,(accessor (slot-symbol s)) obj)
                                         ,encode-form)
                                      encode-form)))))))))
  