anchor.diff:                                     (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 pretty-print indent))))))
  +                                         (print-scalar v type field stream
  +                                                       (and pretty-print indent))))))
                                     (t
                                      (undefined-field-type "While printing ~S to text format,"
                                                            object type field))))
                              (t
  -                            (cond ((keywordp type)
  +                            (cond ((scalarp type)
                                      (let ((v (read-slot object slot reader)))
  -                                     (print-prim v type field stream
  -                                                 (and pretty-print indent))))
  +                                     (print-scalar v type field stream
  +                                                   (and pretty-print indent))))
                                     ((typep (setq msg (and type (or (find-message type)
                                                                     (find-enum type)
                                                                     (find-type-alias type)
  
positive.code:                    (if (null field)
                       (skip-field stream)
                       (cond ((and field (eq (proto-label field) :repeated))
                              (cond ((keywordp type)
                                     (expect-char stream #\:)
                                     (let ((val (case type
                                                  ((:float) (parse-float stream))
  
negative.code:                                    (undefined-field-type "While parsing ~S from text format,"
                                                           msg-desc type field))))
                             (t
                              (cond ((scalarp type)
                                     (expect-char stream #\:)
                                     (let ((val (case type
                                                  ((:float) (parse-float stream))
                                                  ((:double) (parse-double stream))
                                                  ((:string) (parse-string stream))
                                                  ((:bool)   (if (boolean-true-p (parse-token stream))
                                                                 t
                                                                 nil))
                                                  (otherwise (parse-signed-int stream)))))
                                       (when slot
                                         (setf (proto-slot-value object slot) val))))
  