anchor.diff:                                     (let ((v (if slot (read-slot object slot reader) object)))
                                        (when v
                                          (let ((indent (+ indent 2)))
  -                                         (if suppress-pretty-print
  -                                             (format stream "~A { " (proto-name field))
  -                                             (format stream "~&~VT~A {~%" indent (proto-name field)))
  +                                         (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 suppress-pretty-print
  -                                             (format stream "} ")
  -                                             (format stream "~&~VT}~%" indent))))))
  +                                         (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 (not suppress-pretty-print) indent)))))
  +                                                   (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 (not suppress-pretty-print) indent))))))
  +                                                     (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 suppress-pretty-print
  -                                         (format stream "~A: {" (proto-name field))
  +                                     (if pretty-print
                                            (format stream "~&~VT~A: {~%" (+ 2 indent)
  -                                                 (proto-name field)))
  +                                                 (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)
  
positive.code:                             (cond ((keywordp type)
                                     (doseq (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))))
                                            'message-descriptor)
                                     (let ((values (if slot (read-slot object slot reader) (list object))))
                                       (when values
                                         (let ((indent (+ indent 2)))
                                           (dolist (v values)
                                             (if suppress-pretty-print
                                                 (format stream "~A { " (proto-name field))
                                                 (format stream "~&~VT~A {~%" indent (proto-name field)))
                                             (dolist (f (proto-fields msg))
                                               (do-field v indent f))
                                             (if suppress-pretty-print
                                                 (format stream "} ")
                                                 (format stream "~&~VT}~%" indent)))))))
                                    ((typep msg 'enum-descriptor)
                                     (doseq (v (read-slot object slot reader))
                                       (print-enum v msg field stream
                                                   (and (not suppress-pretty-print) indent))))
                                    ((typep msg 'protobuf-type-alias)
                                     (let ((type (proto-proto-type msg)))
                                       (doseq (v (read-slot object slot reader))
                                         (let ((v (funcall (proto-serializer msg) v)))
                                           (print-prim v type field stream
                                                       (and (not suppress-pretty-print) indent))))))
                                    (t
                                     (undefined-field-type "While printing ~S to text format,"
                                                           object type field))))
  
negative.code: 
  (defun print-text-format (object &key (stream *standard-output*)
                                   (print-name t)
                                   (pretty-print t))
    "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.
    PRETTY-PRINT: When true, generate line breaks and other human readable output
      in the text format. When false, replace line breaks with spaces."
    (let* ((type    (type-of object))
           (message (find-message-for-class type)))
      (assert message ()
  