anchor.diff:                                                (if (keywordp val-class)
                                                     (print-prim v val-class nil stream nil)
                                                     (print-text-format v :stream stream
  -                                                                       :suppress-pretty-print t))
  +                                                                       :pretty-print nil))
                                                 (format stream "~%")))
                                          (maphash #'print-entry val)
                                          (format stream "~&~VT}" (+ indent 2)))))
  
positive.code: 
  (defun print-text-format (object &key (stream *standard-output*)
                                   (print-name t)
                                   (suppress-pretty-print nil))
    "Prints a protocol buffer message to a stream.
  Parameters:
    OBJECT: The protocol buffer message to print.
    STREAM: The stream to print to.
    PRINT-NAME: Bool for printing the name of the top level proto message.
    SUPPRESS-PRETTY-PRINT: When true, don't generate line breaks and other human readable output
      in the text format."
    (let* ((type    (type-of object))
           (message (find-message-for-class type)))
      (assert message ()
  
negative.code:                                    (let ((v (if slot (read-slot object slot reader) object)))
                                       (when v
                                         (let ((indent (+ indent 2)))
                                           (if pretty-print
                                               (format stream "~&~VT~A {~%" indent (proto-name field))
                                               (format stream "~A { " (proto-name field)))
                                           (dolist (f (proto-fields msg))
                                             (do-field v indent f))
                                           (if pretty-print
                                               (format stream "~&~VT}~%" indent)
                                               (format stream "} "))))))
                                    ((typep msg 'enum-descriptor)
                                     (let ((v (read-slot object slot reader)))
                                       (when (and v (not (eql v (proto-default field))))
                                         (print-enum v msg field stream
                                                     (and 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
                                                       (and pretty-print indent))))))
                                    ;; todo(benkuehnert): use specified map format
                                    ((typep msg 'map-descriptor)
                                     (let ((key-class (map-descriptor-key-class msg))
                                           (val-class (map-descriptor-val-class msg))
                                           (val (read-slot object slot reader)))
                                       (if pretty-print
                                           (format stream "~&~VT~A: {~%" (+ 2 indent)
                                                   (proto-name field))
                                           (format stream "~A: {" (proto-name field)))
                                       (flet ((print-entry (k v)
                                                (format stream "~&~VT" (+ 4 indent))
                                                (print-prim k key-class nil stream nil)
  