anchor.diff:    (if (eq :all names)
         (if (null package)
             (clrhash *test-db*)
  -          (progn
  -            (remhash (find-package package) *test-db*)
  -            (remhash (find-package package) *tag-db*)))
  +          (remhash (find-package package) *test-db*))
         (let ((table (package-table package)))
           (unless (null table)
             ;; Remove tests
             (loop for name in names
                   always (remhash name table)
                   collect name into removed
  -                finally (return removed))
  -          ;; Remove tests from tags
  -          (loop with tags = (package-tags package)
  -                for tag being each hash-key in tags
  -                using (hash-value tagged-tests)
  -                do
  -                (setf
  -                 (gethash tag tags)
  -                 (set-difference tagged-tests names)))))))
  -
  -;;; Manage tags
  -
  -(defun %tests-from-all-tags (&optional (package *package*))
  -  "Return all of the tests that have been tagged."
  -  (loop for tests being each hash-value in (package-tags package)
  -        nconc (copy-list tests) into all-tests
  -        finally (return (delete-duplicates all-tests))))
  -
  -(defun %tests-from-tags (tags &optional (package *package*))
  -  "Return the tests associated with the tags."
  -  (loop with table = (package-tags package)
  -        for tag in tags
  -        as tests = (gethash tag table)
  -        nconc (copy-list tests) into all-tests
  -        finally (return (delete-duplicates all-tests))))
  -
  -(defun list-tags (&optional (package *package*))
  -  "Return a list of the tags in package."
  -  (let ((tags (package-tags package)))
  -    (when tags
  -      (loop for tag being each hash-key in tags collect tag))))
  -
  -(defun tagged-tests (tags &optional (package *package*))
  -  "Run the tests associated with the specified tags in package."
  -  (if (eq :all tags)
  -      (%tests-from-all-tags package)
  -      (%tests-from-tags tags package)))
  -
  -(defun remove-tags (tags &optional (package *package*))
  -  "Remove individual tags or entire sets."
  -  (if (eq :all tags)
  -      (if (null package)
  -          (clrhash *tag-db*)
  -          (remhash (find-package package) *tag-db*))
  -      (let ((table (package-tags package)))
  -        (unless (null table)
  -          (loop for tag in tags
  -                always (remhash tag table)
  -                collect tag into removed
                   finally (return removed))))))
   
   ;;; Assert macros
  
positive.code:       (%run-all-thunks package)
        (%run-thunks test-names package)))
  
  (defun run-tags (tags &optional (package *package*))
    "Run the tests associated with the specified tags in package."
    (%run-thunks (tagged-tests tags package) package))
  
  (defun set-equal (l1 l2 &key (test #'equal))
    "Return true if every element of l1 is an element of l2 and vice versa."
    (and (listp l1)
  
negative.code:            :run-tests
             :run-koans
             :use-debugger)
    ;; Constants for blanks in koans
    (:export __
             ___
  