anchor.diff:    (loop for elt = ulist then (ucdr elt)
           while elt collect (ucar elt)))
   
  -(defun copy-utree (ulist)
  -  "Return a tree of the same shape as ULIST, but where all occuring ulists
  -   have been converted to lists."
  -  (declare (ulist ulist))
  -  (loop for elt = ulist then (ucdr elt)
  +(defun copy-utree (utree)
  +  "Return a tree of the same shape as UTREE, but where all occuring ulists
  +have been converted to lists."
  +  (declare (ulist utree))
  +  (loop for elt = utree then (ucdr elt)
           while elt
           for car = (ucar elt)
           collect (if (uconsp car)
  
positive.code: ;;; (bench  (list 1 2 3 4 5 6 7 8)) -> 25.77 nanoseconds
  ;;; (bench (ulist 1 2 3 4 5 6 7 8)) -> 38.18 nanoseconds
  
  (declaim (hash-table *ucons-leaf-table*))
  (defvar *ucons-leaf-table* (make-hash-table :test #'eq)
    "The table of all uconses whose cdr is NIL.")
  
  (deftype ucar () 't)
  
  (defstruct (ucons
              (:constructor make-fresh-ucons (car cdr))
              (:copier nil) ; this is the whole point, isn't it?
              (:predicate uconsp)
              (:conc-name u))
    (cdr   nil :type (or structure-object null) :read-only t)
    (car   nil :type ucar  :read-only t)
    (table nil :type (or list hash-table) :read-only nil))
  
  (deftype ulist ()
    "A list made of UCONSes, or NIL."
  
negative.code: 
  (declaim (inline ucons)
           (notinline ucons-leaf ucons-hash ucons-list)
           (ftype (function (ucons)   t)     ucar)
           (ftype (function (ucons)   ulist) ucdr)
           (ftype (function (t ulist) ucons) ucons)
           (ftype (function (t)       ucons) ucons-leaf)
           (ftype (function (t ucons) ucons) ucons-hash ucons-list))
  
  (defun ucons (car cdr)
    "Given a suitable CAR and CDR, return a UCONS that is EQL to all future
  and past invocation of this function with the same arguments."
    (declare (type ulist cdr)
             (optimize (safety 0) (debug 0)))
    (if (null cdr)
        (ucons-leaf car)
        (let ((table (utable cdr)))
          (if (listp table)
              (loop for entry of-type cons in table do
                (when (eql (car entry) car)
                  (return (cdr entry)))
                    finally (return (ucons-list car cdr)))
              (ucons-hash car cdr)))))
  
  ;;; Called for UCONSES with a CDR of NIL
  (defun ucons-leaf (car)
    (values
     (ensure-gethash car *root-table* (make-fresh-ucons car nil))))
  
  ;;; Called if the UTABLE of CDR is a hash table
  (defun ucons-hash (car cdr)
    (declare (ucons cdr))
    (values
     (ensure-gethash car (utable cdr) (make-fresh-ucons car cdr))))
  
  ;;; Called if the UTABLE of CDR is an alist that does not contain CAR.
  (defun ucons-list (car cdr)
    (declare (ucons cdr))
    (let ((ucons (make-fresh-ucons car cdr)))
      (prog1 ucons
        (if (< (length (utable cdr)) 16)
  