anchor.diff:  (defmethod items-in-group ((gl grouped-list) &rest key-values)
     " a list of key values that will produce a list of all the items in a given group"
     (let ((subgroup (grouped-list gl))
  -	(tests (tests gl)))
  +        (tests (tests gl)))
       (iter (for key in key-values)
  -	  (for test = (or (first tests) #'equal))
  -	  (setf tests (rest tests))
  -	  (setf subgroup (%group-subgroups subgroup key test)))
  -    
  +          (for test = (or (first tests) #'equal))
  +          (setf tests (rest tests))
  +          (setf subgroup (%group-subgroups subgroup key test)))
  +
       ;; alists are indistinguishable from lists containing cons cells so...
       ;; do what we know is correct right here
       (when (and (eql :alist (grouping-implementation gl)))
         ;; find the number of levels of alist that we still have left
         (let ((depth-left (- (length (keys gl)) (length key-values) 1 )))
  -	(iter (for i from 0 to depth-left)
  -	      (setf subgroup (iter (for (key . values) in subgroup)
  -				   (appending values))))))
  +        (iter (for i from 0 to depth-left)
  +              (setf subgroup (iter (for (key . values) in subgroup)
  +                                   (appending values))))))
       ;; Get all the items for that subgrouping (for alists this is a list we just produced)
       ;; and that list will simply pass through
       (%grouping-items subgroup)))
  
positive.code: 
  (defmethod add-child ((tree n-ary-tree) child)
    (setf child (typecase child
  		(n-ary-tree child)
  		(T (make-instance 'n-ary-tree :key child))))
    (setf (parent child) tree)
    (push child (children tree))
    child)
  
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"
  