anchor.diff:                  :functor (find-test test)))))
   
   (defun get (key dict &optional default)
  +  (declare #.*interface*)
     (funcall (functor-get (dict-functor dict)) key dict default))
   
   (defun (setf get) (new-value key dict)
  +  (declare #.*interface*)
     (funcall (functor-set (dict-functor dict)) new-value key dict)
     new-value)
   
   (defun remove (key dict)
  +  (declare #.*interface*)
     (funcall (functor-rem (dict-functor dict)) key dict))
   
   (defun count (dict)
  +  (declare #.*interface*)
     (dict-count dict))
   
   (defmacro each ((key value dict &optional return-form) &body body)
     (with-gensyms (node)
  -    `(each-node (,node ,dict ,return-form)
  +    `(each-node (,node (dict-buckets ,dict) ,return-form)
          (let ((,key (node-key ,node))
                (,value (node-value ,node)))
            ,@body))))
   
   (defun map (fn dict &aux acc)
  -  (declare (function fn))
  +  (declare #.*interface*
  +           (function fn))
     (each (key value dict (nreverse acc))
       (push (funcall fn key value) acc)))
  +
  +(defun clear (dict)
  +  (declare #.*interface*)
  +  (with-slots (count buckets) (the dict dict)
  +    (setf count 0)
  +    (fill buckets +TAIL+))
  +  t)
  
positive.code:                (values index pred node))))
      (recur nil (aref (dict-buckets dict) index))))
  
  (defmacro with-candidate ((place node) (hashcode dict) &body body)
    (with-gensyms (bucket-index pred)
      `(multiple-value-bind (,bucket-index ,pred ,node)
                            (find-candidate ,hashcode ,dict)
  
negative.code:                           (key dict hash-fn test-fn) 
                            &key if-existing if-absent)
    `(let ((,hashcode (normalize-hashcode (,hash-fn ,key))))
       (with-candidate (,node ,place) (,hashcode ,dict)
         (if (and (= ,hashcode (node-hash ,node))
                  (,test-fn ,key (node-key ,node)))
             ,if-existing
  