anchor.diff:                                         (parents keymap)))))))
       (apply #'keymap->map (list-keymaps keymap '()))))
   
  -(declaim (ftype (function (&rest keymap) (or keymap null)) compose))
  -(defun compose (&rest keymaps)
  +(declaim (ftype (function (keymap &rest keymap) (or keymap null)) compose))
  +(defun compose (keymap &rest more-keymaps)
     "Return a new keymap that's the composition of all given KEYMAPS.
   KEYMAPS are composed by order of precedence, first keymap being the one with
   highest precedence."
     (flet ((stable-union (list1 list2)
              (delete-duplicates (append list1 list2)
                                 :from-end t)))
  -    (cond
  -      ((uiop:emptyp keymaps)
  -       nil)
  -      ((= 1 (length keymaps))
  -       (first keymaps))
  -      (t
  -       (let ((keymap1 (first keymaps))
  -             (keymap2 (second keymaps))
  -             (merge (make-keymap)))
  -         (setf (default merge) (default keymap1))
  -         (setf (translator merge) (translator keymap1))
  -         (setf (parents merge) (stable-union (parents keymap1) (parents keymap2)))
  -         (setf (entries merge) (fset:map-union (entries keymap2) (entries keymap1)))
  -         (apply #'compose merge (rest (rest keymaps))))))))
  +    (let ((keymaps (cons keymap more-keymaps)))
  +      (cond
  +        ((uiop:emptyp keymaps)
  +         nil)
  +        ((= 1 (length keymaps))
  +         (first keymaps))
  +        (t
  +         (let ((keymap1 (first keymaps))
  +               (keymap2 (second keymaps))
  +               (merge (make-keymap)))
  +           (setf (default merge) (default keymap1))
  +           (setf (translator merge) (translator keymap1))
  +           (setf (parents merge) (stable-union (parents keymap1) (parents keymap2)))
  +           (setf (entries merge) (fset:map-union (entries keymap2) (entries keymap1)))
  +           (apply #'compose merge (rest (rest keymaps)))))))))
   
   (declaim (ftype (function (symbol keymap) list-of-strings) symbol-keys*))
   (defun symbol-keys* (symbol keymap)
  
positive.code:                   :initial-value (fset:empty-map))
       'fset:map)))
  
  (declaim (ftype (function (&rest keymap) hash-table) keymap->map))
  (defun keymap->map (&rest keymaps)
    "Return a hash-table of (KEYSPEC SYM) from KEYMAP.
  Parent bindings are not listed; see `keymap-with-parents->map' instead.
  This is convenient if the caller wants to list all the bindings.
  When multiple keymaps are provided, return the union of the `fset:map' of each arguments.
  Keymaps are ordered by precedence, highest precedence comes first."
    (let ((keymaps (reverse keymaps)))
      (coerce
       (fset:convert 'hash-table
                     (reduce #'fset:map-union
  
negative.code: ;; We can verify this with:
  ;;
  ;;   (compile 'foo (lambda () (keymap::define-key keymap "C-x C-f" 'find-file)))
  (defmacro define-key (keymap binding sym &rest more-binding-sym-pairs)
    "Bind BINDING to SYM in KEYMAP.
  Return KEYMAP.
  
  