anchor.diff:        ;; Printed" indenting for printed source forms
   
         ;; write ftype decl
  -      (write-char #\( stream)
  -      (princ-symbol (quote declaim) stream t)
  -      (princ-space stream)
  -      (write-char #\( stream)
  -      (princ-symbol (quote 'ftype) stream t)
  -      (princ-space stream)
  -      (print (compute-reader-function-type slot class) stream)
  -      (princ-symbol name stream t)
  -      (write-char #\) stream)
  -      (write-char #\) stream)
  -      (terpri stream)
  -      (terpri stream)
  +      (write-reference-expression
  +       `(declaim (ftype ,(compute-reader-function-type slot class)
  +                       name))
  +       stream)
   
         ;; write defun expr
         (write-char #\( stream)
  -      (princ-symbol (quote defun) stream t)
  -      (princ-space stream)
  -      (princ-symbol name stream t)
  -      (princ-space stream)
  +      (write-symbol (quote defun) stream t)
  +      (write-space stream)
  +      (write-symbol name stream t)
  +      (write-space stream)
         ;;
         (destructuring-bind (lsym args &body lform-body) lform
           (declare (ignore lsym))
  -        (print args stream)
  +        (write-reference-expression args stream)
           (when docstr (print docstr stream))
           (dolist (expr lform-body)
  -          (print expr stream)))
  +          (write-reference-expression expr stream)
  +          (terpri stream)))
         ;;
         (write-char #\) stream)
   
  
positive.code:   ;;  - This function will not access any packgage nicknames
    ;;  - This function will not assume that any symbol is exported
    ;;
    (declare (type (or symbol string) s) (type stream stream)
             (values stream &optional))
    (macrolet ((the-string (expr)
                 (with-symbols (%expr)
                   `(let ((,%expr ,expr))
                      (etypecase ,%expr
                        (symbol (symbol-name ,%expr))
                        (string ,%expr)))))
               (the-pkg-string (expr)
                 (with-symbols (%expr)
                   `(let ((,%expr ,expr))
                      (etypecase ,%expr
                        (symbol (package-name (symbol-package ,%expr)))
                        (t (package-name *package*)))))))
      (when  pkg-p
        (princ (the-pkg-string s) stream)
        (write-char #\: stream) (write-char #\: stream))
      (princ (the-string s) stream)
      (values stream)))
  
  ;; (with-output-to-string (s) (princ-symbol 'frob s))
  ;; => "FROB"
  
  ;; (with-output-to-string (s) (princ-symbol 'lambda s t))
  ;; => "COMMON-LISP::LAMBDA"
  
  
  (defun* princ-space (stream)
    (declare (type stream stream)
             (values stream &optional))
    (write-char #\Space stream)
    (values stream))
  
  ;; ----
  
  
negative.code: 
  
  ;; TBD: Applciation of *PRINT-READABLY* as a default value for the PKG-P
  ;; parameter to WRITE-SYMBOL, in this system - in lieu of a definition
  ;; of any additoinal globally scoped variable or generalized manner of
  ;; "Application Flag" singularly for affecting that behavior of this
  ;; system, per se.
  
  (declaim (inline write-symbol
                   write-space))
  
  (defun* write-symbol (s stream &optional pkg-p)
    ;; NB: If S is a string, it's assumed that any character in S such
    ;; that may have a particular interpretation in a symbol name, if
    ;; unescaped, will have already been escaped by the calling procedure.
  