anchor.diff:                                                    ((:float) (parse-float stream))
                                                     ((:double) (parse-double stream))
                                                     ((:string) (parse-string stream))
  -                                                  ((:bool)   (if (boolean-true-p (parse-token stream)) t nil))
  +                                                  ((:bool)   (if (boolean-true-p
  +                                                                  (parse-token stream))
  +                                                                 t
  +                                                                 nil))
                                                     (otherwise (parse-signed-int stream)))))
                                          (when slot
                                            (pushnew slot rslots)
  
positive.code:                         msg)
                     (when (has-struct-field-p object field)
                       (cond ((eq (proto-label field) :repeated)
                              (cond ((keywordp type)
                                     (doseq (v (read-slot object slot reader))
                                       (print-prim v type field stream
                                                   (and pretty-print indent))))
                                    ((typep (setq msg (and type (or (find-message type)
                                                                    (find-enum type)
                                                                    (find-type-alias type))))
  
negative.code:                                          (format stream "~A: {" (proto-name field)))
                                       (flet ((print-entry (k v)
                                                (format stream "~&~VT" (+ 4 indent))
                                                (print-scalar k key-class nil stream nil)
                                                (format stream "-> ")
                                                (if (scalarp val-class)
                                                    (print-scalar v val-class nil stream nil)
                                                    (print-text-format v :stream stream
                                                                         :pretty-print nil))
                                                (format stream "~%")))
  