anchor.diff:    (if (null keys)
         (push item root)
         (let ((key (funcall (first keys) item)))
  -	(let ((data (assoc key root :test (or (first tests) #'equal))))
  -	  (if data
  -	      ;; Add the rest of the categorization to the
  -	      ;; data of this item
  -	      (setf (cdr data) (categorize-item
  -				item (cdr data)
  -				:keys (rest keys)
  -				:tests (rest tests)))
  -	      ;; we have no data for this node, build a new subtree
  -	      (push (cons key (categorize-item
  -			       item nil
  -			       :keys (rest keys)
  -			       :tests (rest tests)))
  -		    root)))))
  +        (let ((data (assoc key root :test (or (first tests) #'equal))))
  +          (if data
  +              ;; Add the rest of the categorization to the
  +              ;; data of this item
  +              (setf (cdr data) (categorize-item
  +                                item (cdr data)
  +                                :keys (rest keys)
  +                                :tests (rest tests)))
  +              ;; we have no data for this node, build a new subtree
  +              (push (cons key (categorize-item
  +                               item nil
  +                               :keys (rest keys)
  +                               :tests (rest tests)))
  +                    root)))))
     root)
   
   (defun group-by-repeated (list &key keys tests)
     "Returns an alist tree that represents the items in the list as categorized
      by keys (compared with tests)
       ex: ((a 3 sam) (c 4 bob) (a 3 ted))
  -     
  -   
  +
  +
      keys: a list of key functions that describe the categorizations in order
      tests: how we are testing whether or not two keys are equal, defaults to #'equal
     "
     (let (root)
       (iter (for item in list)
  -	  (setf root (categorize-item item root :keys keys :tests tests)))
  +          (setf root (categorize-item item root :keys keys :tests tests)))
       root))
   
   (defmethod categorize-item (item (root n-ary-tree) &key keys tests)
     (iter (with node = root)
  -	(with tests = tests)
  -	(for keyfn in keys)
  -	(for testfn = (or (first tests) #'equal))
  -	(setf tests (rest tests))
  -	(for key = (funcall keyfn item))
  -	(setf node
  -	      (or (find key (children node) :key #'key :test testfn)
  -		  (add-child node key)))
  -	(finally (push item (data node))))
  +        (with tests = tests)
  +        (for keyfn in keys)
  +        (for testfn = (or (first tests) #'equal))
  +        (setf tests (rest tests))
  +        (for key = (funcall keyfn item))
  +        (setf node
  +              (or (find key (children node) :key #'key :test testfn)
  +                  (add-child node key)))
  +        (finally (push item (data node))))
     root)
   
   (defun group-by-repeated-in-tree (list &key keys tests)
  
positive.code:     "What data structure should be used to perform the grouping
         :alist, :tree , :hash-table")
     (keys :accessor keys :initarg :keys :initform nil
  	 :documentation "A list of key functions we will use to group the list")
     (tests :accessor tests :initarg :tests :initform nil
  	  :documentation "A list of test functions we will use to test key equality
        tree: defaults to #'equal
        hash-table: this be a single hash-equality symbol (defaults to 'equal)")
     (grouped-list :accessor grouped-list :initarg :grouped-list :initform nil
  		 :documentation "a list grouped according to the grouping-implementation")
     (parent-grouping :accessor parent-grouping :initarg :parent :initform nil
      :documentation "If this is a subgrouping of another grouped-list, what is the parent grouping we are apart of (mostly for testing)")
     (key-value :accessor key-value :initarg :key-value :initform nil
  
negative.code:   grouped-list-speed-tester for help deciding which to use)
    "
    (make-instance 'grouped-list
                   :tests tests
                   :keys keys
                   :grouping-implementation grouping-implementation
                   :orig-list inp))
  
  (defmethod initialize-instance :after ((o grouped-list) &key list &allow-other-keys)
    (when list (setf (orig-list o) list))
    (unless (grouped-list o)
      (setf (grouped-list o)
            (apply
             (ecase (grouping-implementation o)
               (:hash-table #'group-by-repeated-in-hash-table)
               (:tree #'group-by-repeated-in-tree)
               (:alist #'group-by-repeated ))
             (list (orig-list o) :keys (keys o) :tests (tests o))))))
  
  (defmethod add-item-to-grouping (item (gl grouped-list))
    "puts a new item in the grouping of the grouped list (but not in the original list)"
    (setf (grouped-list gl)
          (categorize-item item (grouped-list gl) :keys (keys gl) :tests (tests gl))))
  
  (defmethod %group-subgroups ((l list) key-value test &optional default)
    "Returns the sub groups for the different grouping implementations"
  