anchor.diff:  (defmethod categorize-item (item (root hash-table) &key keys tests)
     "puts an item in a hash-table grouping as produced by group-by-repeated-in-hash-table"
     (iter (with node = root)
  -	(for keyfn on keys)
  -	(for key = (funcall (first keyfn) item))
  -	(for testsym = (or (typecase (first tests)
  -			     (symbol (first tests)))
  -			   'equal))
  -	(setf tests (rest tests))
  -	(when (rest keyfn)
  -	  (setf node (alexandria:ensure-gethash
  -		      key node
  -		      (make-hash-table :test testsym))))
  -	(finally (let ((data (gethash key node)))
  -		   (push item data)
  -		   (setf (gethash key node) data))))
  +        (for keyfn on keys)
  +        (for key = (funcall (first keyfn) item))
  +        (for testsym = (or (typecase (first tests)
  +                             (symbol (first tests)))
  +                           'equal))
  +        (setf tests (rest tests))
  +        (when (rest keyfn)
  +          (setf node (alexandria:ensure-gethash
  +                      key node
  +                      (make-hash-table :test testsym))))
  +        (finally (let ((data (gethash key node)))
  +                   (push item data)
  +                   (setf (gethash key node) data))))
     root)
   
   (defun group-by-repeated-in-hash-table (list &key keys tests)
  
positive.code: (defpackage :group-by
      (:use :cl :cl-user :iter)
    (:export :group-by
  	   :categorize-item
  	   :grouped-list
  	   :make-grouped-list
  	   :add-item-to-grouping
  	   :key-value
  	   :child-groupings
  	   :items-in-group
  	   :parent-grouping
  	   :keys :tests
  	   :make-child-grouped-list
  	   :group-by-repeated
  	   :group-by-repeated-in-hash-table
  	   :group-by-repeated-in-tree
  	   :grouped-list-speed-tester))
  
  (in-package :group-by)
  
  
negative.code: (defmethod %grouping-children ((gl grouped-list) (l list))
    (when (keys gl)
      (iter (for (key . value) in l)
            (collect (make-child-grouped-list gl key value)))))
  
  (defmethod %grouping-children ((gl grouped-list) (tn n-ary-tree))
    (when (keys gl)
      (iter (for i in (children tn))
            (collect (make-child-grouped-list gl (key i) i)))))
  
  (defmethod %grouping-children ((gl grouped-list) (h hash-table))
    (when (keys gl)
      (iter (for (key value) in-hashtable h)
            (collect (make-child-grouped-list gl key value)))))
  
  (defmethod child-groupings ((gl grouped-list))
    (%grouping-children gl (grouped-list gl)))
  