anchor.diff:                              (cond ((keywordp type)
                                      (let ((v (read-slot object slot reader)))
                                        (print-prim v type field stream
  -                                                 (and (not suppress-pretty-print) indent))))
  +                                                 (and pretty-print indent))))
                                     ((typep (setq msg (and type (or (find-message type)
                                                                     (find-enum type)
                                                                     (find-type-alias type)
  
positive.code:                                               (if (keywordp val-class)
                                                    (print-prim v val-class nil stream nil)
                                                    (print-text-format v :stream stream
                                                                         :suppress-pretty-print t))
                                                (format stream "~%")))
                                         (maphash #'print-entry val)
                                         (format stream "~&~VT}" (+ indent 2)))))
  
negative.code:                                                          object type field)))))))))
          (declare (dynamic-extent #'do-field))
          (if print-name
              (if pretty-print
                  (format stream "~&~A {~%" (proto-name message))
                  (format stream "~A { " (proto-name message)))
              (format stream "{"))
          (dolist (f (proto-fields message))
            (do-field object 0 f))
          (if pretty-print
              (format stream "~&}~%")
              (format stream "}"))
          nil))))
  
  (defun print-prim (val type field stream indent)
  