anchor.diff:    (declare (type (or null ucons) cdr)
              (type ucar car))
     (let ((alist (and cdr
  -                    (listp (ucons-table cdr))
  -                    (ucons-table cdr))))
  +                    (listp (utable cdr))
  +                    (utable cdr))))
       (the ucons
            (or
             (loop for cons of-type (cons ucar ulist) in alist
  
positive.code: (defstruct (ucons
              (:constructor make-fresh-ucons (car cdr))
              (:copier nil) ; this is the whole point, isn't it?
              (:predicate uconsp))
    (cdr   nil :type ulist :read-only t)
    (car   nil :type ucar  :read-only t)
    (table nil :type (or list hash-table) :read-only nil))
  
  ;;; provide classical slot readers like UCAR and UCADDR
  (macrolet
      ((define-ucxr-accessors ()
         (let (ucxr-forms)
           (flet ((add-ucxr-form (&rest characters)
                    (let ((name (intern (format nil "UC~{~C~}R" characters)))
                          (body 'x))
                      (dolist (char (reverse characters))
                        (ecase char
                          (#\A (setf body `(ucons-car ,body)))
                          (#\D (setf body `(ucons-cdr ,body)))))
                      (push `(defun ,name (x) (declare (ucons x)) ,body) ucxr-forms)
                      (push `(declaim (inline ,name)) ucxr-forms))))
             (map-product #'add-ucxr-form #1='(#\A #\D))
             (map-product #'add-ucxr-form #1# #1#))
           `(progn ,@ucxr-forms))))
    (define-ucxr-accessors))
  
  (declaim (hash-table *ucons-leaf-table*))
  (defvar *ucons-leaf-table* (make-hash-table :test #'eq)
  
negative.code:         (t
           (write-string "[" stream)
           (loop while ulist do
             (write (ucar ulist) :stream stream)
             (when (ucdr ulist)
               (write-string " " stream))
             (setf ulist (ucdr ulist)))
           (write-string "]" stream))))
  