anchor.diff:            (some (lambda (keymap)
                     (if (find keymap visited)
                         (warn "Cycle detected in keymap ~a" keymap)
  -                      (let ((hit (lookup-keys-in-keymap-and-parents
  +                      (let ((hit (lookup-keys-in-keymap
                                     keymap
                                     keys
                                     (cons keymap visited))))
                           (when hit
                             (setf matching-keymap keymap)
                             hit))))
  -                (uiop:ensure-list keymap-or-keymaps))))
  +                (keymap-tree->list (uiop:ensure-list keymap-or-keymaps) '()))))
       (values result matching-keymap)))
   
   (declaim (ftype (function ((or list-of-keys keyspecs-type)
  
positive.code:            nil)
            (t hit))))))
  
  (declaim (ftype (function (keymap
                             list-of-keys
                             list-of-keymaps)
                            (or keymap t))
                  lookup-keys-in-keymap-and-parents))
  (defun lookup-keys-in-keymap-and-parents (keymap keys visited)
    "Return the bound value or keymap associated to KEYS in KEYMAP.
  Return nil if there is none.
  Keymap parents are looked up one after the other.
  VISITED is used to detect cycles."
    (or (lookup-keys-in-keymap keymap keys visited)
        (some (lambda (map)
                (lookup-key* map keys visited))
              (parents keymap))))
  
  (declaim (ftype (function ((or keymap list-of-keymaps)
                             list-of-keys
  
negative.code: 
  Return NIL if no value is found.
  
  First keymap parents are looked up one after the other.
  Then keys translation are looked up one after the other.
  The same is done for the successive keymaps if KEYMAP-OR-KEYMAPS is a list of
  keymaps."
  