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: 
    (define-key foo-map \"C-M-#1\" 'find-file)"
    ;; The type checking of KEYMAP is done by `define-key*'.
    (loop :for (binding sym . rest) :on binding-sym-pairs :by #'cddr
          :do (check-type binding (or keyspecs-type list)))
    `(progn
       ,@(loop :for (binding sym . rest) :on binding-sym-pairs :by #'cddr
               :collect (list 'define-key* keymap binding sym))
       ,keymap))
  
  (declaim (ftype (function (keymap (or keyspecs-type list) (or symbol keymap))) define-key*))
  (defun define-key* (keymap binding sym)
  
negative.code:              (keymap->map keymap))
      (sort result #'string<)))
  
  (declaim (ftype (function (symbol keymap &rest keymap) list) symbol-keys))
  (defun symbol-keys (symbol keymap &rest more-keymaps) ; TODO: Return hash-table or alist?
    "Return a the list of `keyspec's bound to SYMBOL in KEYMAP."
    (coerce (alex:mappend (lambda (keymap)
                            (let ((hit (symbol-keys* symbol keymap)))
                              (when hit
                                (mapcar (alex:rcurry #'list keymap) hit))))
                          (cons keymap more-keymaps))
            'list))
  
  ;; TODO: Remap binding, e.g.
  