anchor.diff:                    (find-map-descriptor type))))
       (cond ((scalarp type)
              (case type
  -             ((:float)  (parse-float stream))
  +             ((:float) (parse-float stream))
                ((:double) (parse-double stream))
                ((:string) (parse-string stream))
  -             ((:bool)   (let ((token (parse-token stream)))
  -                          (cond ((string= token "true") t)
  -                                ((string= token "false") nil)
  -                                ;; Parsing failed, return T as
  -                                ;; a second value to indicate a
  -                                ;; failure.
  -                                (t (values nil t)))))
  -             ((:bytes)  (cl-base64:base64-string-to-usb8-array (parse-string stream)))
  -             (otherwise (if (eql (peek-char nil stream nil) #\")
  -                            (let (ret)
  -                              (expect-char stream #\")
  -                              (setf ret (parse-signed-int stream))
  -                              (expect-char stream #\")
  -                              ret)
  -                            (parse-signed-int stream)))))
  +             ((:bool)
  +              (let ((token (parse-token stream)))
  +                (cond ((string= token "true") t)
  +                      ((string= token "false") nil)
  +                      ;; Parsing failed, return T as a second
  +                      ;; value to indicate a failure.
  +                      (t (values nil t)))))
  +             ((:bytes)
  +              (cl-base64:base64-string-to-usb8-array (parse-string stream)))
  +             (otherwise
  +              (if (eql (peek-char nil stream nil) #\")
  +                  (let (ret)
  +                    (expect-char stream #\")
  +                    (setf ret (parse-signed-int stream))
  +                    (expect-char stream #\")
  +                    ret)
  +                  (parse-signed-int stream)))))
             ((typep desc 'message-descriptor)
              (parse-json desc :stream stream))
             ((typep desc 'enum-descriptor)
  
positive.code:     (when indent (format stream "~%"))
      ;; Boolean that tracks if a field is printed. Used for printing commas
      ;; correctly.
      (let ((field-printed nil))
        (dolist (field (proto-fields message))
          (when (if (eq (slot-value field 'message-type) :extends)
                    (has-extension object (slot-value field 'internal-field-name))
  
negative.code:                     ((#\n)
                       (let ((tok (parse-token stream)))
                         (unless (string= tok "null")
                           (setf error-p t))))))
                (cond
                  (error-p
                   (undefined-field-type "While parsing ~S from JSON format,"
  