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 umapcar))
  (defun umapcar (function &rest sequences)
    "Return an ulist containing the results of applying FUNCTION to
  successive elements of the supplied sequences.  The resulting ulist is as
  long as the shortest supplied sequence."
    (declare (dynamic-extent sequences)
             (function function))
    (let ((length (reduce #'min sequences :key #'length))
  