anchor.diff:             (tre:make-symbol x.)
              x.))))
   
  -(defun read-symbol-or-slot-value (sym pkg)
  +(defun read-symbol-or-slot-value (pkg sym)
     (alet (@ [& _ (list-string _)]
              (split #\. sym))
       (? (& .! !. (car (last !)))
          (read-slot-value !)
          (tre:make-symbol (list-string sym)
                           (?
  -                          (not pkg)  nil
  -                          (t? pkg)   *keyword-package*
  -                          (list-string pkg))))))
  +                          (not pkg)    nil
  +                          (cons? pkg)  (list-string pkg)
  +                          pkg)))))
   
   (defun read-atom (str token pkg sym)
     (case token :test #'eq
  
positive.code:          (read-atom str token pkg sym)))))
  
  (defun read (&optional (str *standard-input*))
    (skip-spaces str)
    (& (peek-char str)
  	 (read-expr str)))
  
  (defun read-all (str)
    (skip-spaces str)
    (& (peek-char str)
       (. (read str)
          (read-all str))))
  
negative.code: 	   (skip-spaces str)
  	   (skip-comment str))))
  
  (defun semicolon? (x)
    (& x (== x #\;)))
  
  (defun skip-spaces (str)
    (when (semicolon? (peek-char str))
      (skip-comment str))
    (when (whitespace? (peek-char str))
      (read-char str)
      (skip-spaces str)))
  
  (defun seek-char (str)
    (skip-spaces str)
    (peek-char str))
  
  (defun read-symbol (str)
    (with (f #'(()
                  (& (symbol-char? (peek-char str))
                     (. (char-upcase (read-char str))
                        (f)))))
      (unless (special-char? (seek-char str))
        (f))))
  
  (defun read-symbol-and-package (str)
    (alet (read-symbol str)
      (? (== (peek-char str) #\:)
         (values (| ! *keyword-package*)
                 (& (read-char str)
                    (read-symbol str)))
         (values nil !))))
  
  (defun read-string (str)
    (with (f #'(()
                  (alet (read-char str)
                    (unless (== ! #\")
                      (. (? (== ! #\\)
                            (read-char str)
                            !)
                         (f))))))
      (list-string (f))))
  
  (defun read-comment-block (str)
    (while (not (& (== #\| (read-char str))
  