anchor.diff:  ;;; ========================================================================
   ;;; DEFINE/UNDEFINE FUNCTIONS
   
  -(defun defpseudonym (raw-name raw-pseudonym &key (package (package-name *package*)))
  +(defun defpseudonym (package pseudonym &key (inside-package (package-name *package*)))
     "This, given a package name and a pseudonym for it, allows you to use a local pseudonym in
   form $pseudonym:symbol instead of name:symbol within your code. This pseudonym is local to the
   package you called defpseudonym in (as shown by the global variable *PACKAGE*).
  
positive.code: (defun pseudonym-reader (stream char)
    "This is the reader macro for local pseudonyms."
    (declare (ignore char))
    (let* ((table (gethash (string-downcase (package-name *package*)) *pseudonym-table*))
  	 (pseudlist (loop for char = (read-char stream)
  		       collect char
  		       until (equal (peek-char nil stream) #\:)))
  	 (pseudonym (string-downcase (concatenate 'string pseudlist)))
  	 (name (string=-getf-key table pseudonym))
  	 (symbol (read stream)))
      ;;(format t "debug: ~A ~A ~A ~A ~A ~A~%"
      ;;(string-downcase (package-name *package*))
      ;;pseudlist pseudonym table name symbol)
      (assert (not (null name)) ()
  	    "Pseudonym ~S was not set. Check your spelling or use defpseudonym."
  	    pseudonym)
      (read-from-string (format nil "~A:~A" name symbol))))
  
  ;; todo: named readtables
  
negative.code: Pseudonyms are always converted to lowercase.
  
  This will signal an error whenever a nickname or pseudonym is already taken."
    (check-type package string-designator)
    (check-type pseudonym string)
    (check-type inside-package string-designator)
    (assert (not (member "" (list package pseudonym inside-package) :test #'string=))
  	  (package pseudonym inside-package)
  	  "Arguments may not be empty strings.")
    (let* ((table (gethash inside-package *pseudonym-table*))
  	 (first (car table))
  	 (package (string package))
  	 (inside-package (string inside-package)))
      (assert (not (string=-getf-key table pseudonym))
  	    (pseudonym)
  	    "This package is already taken by pseudonym ~S."
  	    (string=-getf table package))
      (assert (not (string=-getf table package))
  	    (package)
  	    "This pseudonym is already taken by package ~S."
  	    (string=-getf-key table pseudonym))
      (if (null table)
  	(setf (gethash inside-package *pseudonym-table*)
  	      (cons package (cons pseudonym nil)))
  	(setf (car table) package
  	      (cdr table) (cons pseudonym (cons first (cdr table)))))
      (format nil "~A => ~A" pseudonym  package)))
  
  (defun pmakunbound (datum &key (inside-package (package-name *package*)))
    "This, given either a nickname-bound package name or a package name-bound nickname, clears
  any name-nickname pair bound to it.
  
  Argument must be a string designator.
  An optional argument allows you to clear a pseudonym from a different package."
    (check-type datum string-designator)
    (let ((table (gethash inside-package *pseudonym-table*))
  	(datum (string datum)))
      (setf (gethash inside-package *pseudonym-table*)
  	  (loop for (key value) on table by #'cddr
  	     unless (or (equal key datum) (equal value datum))
  	     collect key and collect value)))
    datum)
  
  ;;; ========================================================================
  ;;; UTILITIES
  
  (defun print-pseudonyms (&key (inside-package (package-name *package*)))
    "This prints all pseudonyms in a fancy manner.
  Optional argument designates the package name, from inside which pseudonyms should be printed."
    (check-type inside-package string)
    (let* ((table (gethash inside-package *pseudonym-table*)))
      (if (null table)
  	(format t "No pseudonyms defined for package ~:@(~A~).~%" inside-package)
  	(progn
  	  (format t "pseudonym => name (inside package ~:@(~A~)):~%" inside-package)
  	  (list-length
  	   (loop for (key value) on table by #'cddr collecting key
  	      do (format t "~S => ~S~%" value key)))))))
  