anchor.diff:                                     (let ((v (read-slot object slot reader)))
                                        (when (and v (not (eql v (proto-default field))))
                                          (print-enum v msg field stream
  -                                                   (or suppress-pretty-print indent)))))
  +                                                   (and (not suppress-pretty-print) indent)))))
                                     ((typep msg 'protobuf-type-alias)
                                      (let ((v (read-slot object slot reader)))
                                        (when v
                                          (let ((v    (funcall (proto-serializer msg) v))
                                                (type (proto-proto-type msg)))
                                            (print-prim v type field stream
  -                                                     (or suppress-pretty-print indent))))))
  +                                                     (and (not suppress-pretty-print) indent))))))
                                     (t
                                      (undefined-field-type "While printing ~S to text format,"
                                                            object type field)))))))))
  
positive.code:          (format stream "\"~A\"" val)))
        ((:date :time :datetime :timestamp)
         (format stream "~D" val)))
      (if (eq indent 't)
        (format stream " ")
        (format stream "~%"))))
  
  (defun print-enum (val enum field stream indent)
    (when val
      (if (eq indent 't)
        (format stream "~A: " (proto-name field))
        (format stream "~&~VT~A: " (+ indent 2) (proto-name field)))
      (let ((name (let ((e (find (keywordify val)
                                 (protobuf-enum-values enum)
                                 :key #'protobuf-enum-value-value)))
                    (and e (protobuf-enum-value-value e)))))
        (format stream "~A" name)
        (if (eq indent 't)
          (format stream " ")
          (format stream "~%")))))
  
  
  ;;; Parse objects that were serialized using the text format
  
negative.code:                             (cond ((keywordp type)
                                     (let ((v (read-slot object slot reader)))
                                       (print-prim v type field stream
                                                   (and (not suppress-pretty-print) indent))))
                                    ((typep (setq msg (and type (or (find-message type)
                                                                    (find-enum type)
                                                                    (find-type-alias type))))
  