anchor.diff:  
   (defun json-key (symb)
     "Return the symbol produced by JSON encoding and decoding SYMB."
  -  (funcall json::*identifier-name-to-key*
  -           (json:decode-json-from-string
  -            (funcall json::*json-identifier-name-to-lisp*
  -                     (json:encode-json-to-string symb)))))
  +  (let ((json:*lisp-identifier-name-to-json* #'lisp-to-snake-case)
  +        (json:*json-identifier-name-to-lisp* #'snake-case-to-lisp))
  +    (let ((result (funcall json::*identifier-name-to-key*
  +                           (json:decode-json-from-string
  +                            (funcall json::*json-identifier-name-to-lisp*
  +                                     (json:encode-json-to-string symb))))))
  +      (format *debug-io* "JSON-KEY result: ~S~%" result)
  +      result)))
   
   (eval-when (:compile-toplevel :load-toplevel :execute)
     (defun serial-slot-p (s)
       (or (symbolp s)
           (and (listp s)
  -             (destructuring-bind (name &key (marshall t) &allow-other-keys)
  +             (destructuring-bind (name field &key (marshall t) &allow-other-keys)
                    s
  -               (declare (ignore name))
  +               (declare (ignore name field))
                  marshall))))
   
     (defun optional-slot-p (s)
       (and (listp s)
  -         (getf (rest s) :optional)))
  +         (getf (cddr s) :optional)))
   
     (defun slot-symbol (s)
       (etypecase s
  -      (symbol s)
         (list (destructuring-bind (name &rest r) s
                 (declare (ignore r))
                 name))))
   
  +  (defun slot-key (s)
  +    (second s))
  +
     (defun slot-marshall-type (s)
       (etypecase s
  -      (symbol nil)
  -      (list (getf (rest s) :marshall-type))))
  +      (list (getf (cddr s) :marshall-type))))
   
     (defun cat-symbol (symbol &rest rest)
  -  (intern (format nil "~{~A~}" (mapcar #'symbol-name
  -                                       (cons symbol rest)))))
  +    (intern (format nil "~{~A~}" (mapcar #'symbol-name
  +                                         (cons symbol rest)))))
   
     (defun slot-optional-p (slot type)
       (check-type type symbol)
  
positive.code:          (mapcar #',(cat-symbol '#:build- type) obj))
         (defun ,(cat-symbol '#:unmarshall- name) (str)
           (check-type str string)
           (let ((obj (json:decode-json-from-string str)))
             (,(cat-symbol '#:build- name) obj))))))
  
  (define-object-array rpc-request rpc-call)
  
negative.code: 
  (define-json-obj rpc-call
    "A single method invocation."
    (service "service" :initial "" :type string :read-only t)
    (method "method" :initial "" :type string :read-only t)
    (args "args" :initial '() :type list :read-only t :marshall-type arg-list)
    (id "id" :initial nil :optional :read :read-only t))
  
  (define-json-obj rpc-error
    "Error object contained in a failed rpc-result."
    (message "message" :initial "" :type string :read-only t)
    (code "code" :initial 0 :read-only t)
    (data "data" :initial nil :read-only t :optional :read-write))
  
  (define-json-obj rpc-result
    "The result of an RPC method invocation."
    (data "data" :initial nil :optional :read-write :read-only t)
    (error "error" :initial nil :optional :read-write :read-only t :marshall-type rpc-error)
    (warnings "warnings" :initial '() :optional :read-write :read-only t :marshall-type rpc-warning-list)
    (id "id" :intitial nil :optional :read-write :read-only t))
  
  (defmacro define-object-array (name type)
    (let* ((predicate-name (cat-symbol name '#:-p))
  