anchor.diff:    t)
   
   (defun add-translator (table translator)
  -  ;; Remove old one.
  -  (when-let ((old (gethash (name translator) (translators table))))
  -    (alexandria:removef (gethash (presentation-type-name (from-type old))
  -                                 (simple-type-translators table))
  -                        old))
     (invalidate-translator-caches)
     (setf (gethash (name translator) (translators table)) translator)
  -  (push translator (gethash (presentation-type-name (from-type translator))
  -                            (simple-type-translators table)))
     translator)
   
   (defun remove-translator (table translator)
  -  (alexandria:removef (gethash (presentation-type-name (from-type translator))
  -                               (simple-type-translators table))
  -                      translator)
     (remhash (name translator) (translators table))
     (invalidate-translator-caches)
     translator)
  
positive.code:         ;; priority is (mod priority 10) That's pretty wacked...
          (flet ((translator-lessp (a b)
                   (nest
                    (destructuring-bind (translator-a . table-num-a) a)
                    (destructuring-bind (translator-b . table-num-b) b)
                    (multiple-value-bind (hi-a low-a) (floor (priority translator-a) 10))
                    (multiple-value-bind (hi-b low-b) (floor (priority translator-b) 10))
                    (let* ((a-name (presentation-type-name (from-type translator-a)))
                           (b-name (presentation-type-name (from-type translator-b)))
                           (a-precedence (position a-name from-super-names))
                           (b-precedence (position b-name from-super-names)))
                      (cond
                        ;; 1. High order priority
                        ((> hi-a hi-b) (return-from translator-lessp t))
                        ((< hi-a hi-b) (return-from translator-lessp nil))
                        ;; 2. More specific "from type"
                        ((< a-precedence b-precedence) (return-from translator-lessp t))
                        ((> a-precedence b-precedence) (return-from translator-lessp nil))
                        ;; 3. Low order priority
                        ((> low-a low-b) (return-from translator-lessp t))
                        ((< low-a low-b) (return-from translator-lessp nil))
                        ;; 4. Command table inheritance
                        (t (< table-num-a table-num-b)))))))
            ;; Add translators to their caches.
            (let ((translators (map 'list #'car (sort translator-vector #'translator-lessp))))
              (setf (gethash cache-key cache-table)
                    (remove-duplicates translators))))))))
  
  
negative.code: 
  (defun find-presentation-translators (from-type to-type command-table)
    (let* ((command-table (find-command-table command-table))
           (from-name     (presentation-type-name from-type))
           (to-name       (presentation-type-name to-type))
           (cache-key     (cons from-type to-name))
           (cache-table   (presentation-translators-cache
                           (presentation-translators command-table))))
      (when-let ((cached-translators (gethash cache-key cache-table)))
        (return-from find-presentation-translators cached-translators))
      (let ((translator-vector (make-array 8 :adjustable t :fill-pointer 0))
            (table-counter 0))
        (do-command-table-inheritance (table command-table)
          ;; We need to go over each translator in all tables, because
          ;; the FROM-TYPE may be a subtype of a translator FROM-TYPE
          ;; despite not having the same presentation metaclass, like
          ;; "meta" presentation types OR, AND etc. -- jd 2020-06-24
          (loop with translators = (translators (presentation-translators table))
                for tr being the hash-value of translators
                if (and (stupid-subtypep from-type (from-type tr))
                        (stupid-subtypep (to-type tr) to-type))
                  do (vector-push-extend (cons tr table-counter)
                                         translator-vector))
          (incf table-counter))
        (let ((from-super-names nil))
          (map-over-ptype-superclasses #'(lambda (super)
  