anchor.diff:    "Return a keyspecs"
     (coerce (str:join " " (mapcar #'key->keyspec keys)) 'keyspecs-type))
   
  -;; TODO: Declare types.
  +(declaim (ftype (function (keymap &optional (types:proper-list keymap)) fset:map) keymap->map*))
   (defun keymap->map* (keymap &optional visited) ; TODO: Return a regular hash-table instead?
     "Return a `fset:map' of (KEYSPEC SYM) from KEYMAP."
  -  (fset:reduce
  -   (lambda (result key sym)
  -     (let ((keyspec (key->keyspec key)))
  -       (if (keymap-p sym)
  -           (cond
  -             ((find sym visited)
  -              (warn "Cycle detected in keymap ~a" keymap)
  -              result)
  -             (t
  -              (fset:map-union result
  -                              (fset:image (lambda (subkey subsym)
  -                                            (values (format nil "~a ~a" keyspec subkey)
  -                                                    subsym))
  -                                          (keymap->map* sym (cons sym visited))))))
  -           (fset:with result keyspec sym))))
  -   (entries keymap)
  -   :initial-value (fset:empty-map)))
  -
  +  (coerce
  +   (fset:reduce
  +    (lambda (result key sym)
  +      (let ((keyspec (key->keyspec key)))
  +        (if (keymap-p sym)
  +            (cond
  +              ((find sym visited)
  +               (warn "Cycle detected in keymap ~a" keymap)
  +               result)
  +              (t
  +               (fset:map-union result
  +                               (fset:image (lambda (subkey subsym)
  +                                             (values (format nil "~a ~a" keyspec subkey)
  +                                                     subsym))
  +                                           (keymap->map* sym (cons sym visited))))))
  +            (fset:with result keyspec sym))))
  +    (entries keymap)
  +    :initial-value (fset:empty-map))
  +   'fset:map))
  +
  +(declaim (ftype (function (&rest keymap) fset:map) keymap->map))
   (defun keymap->map (&rest keymaps)
     "Return a `fset:map' of (KEYSPEC SYM) from KEYMAP.
   Parent bindings are not listed; see `keymap-with-parents->map' instead.
  
positive.code:     (reduce #'fset:map-union
              (mapcar #'keymap->map* keymaps))))
  
  (defun keymap-with-parents->map (keymap)
    "List bindings in KEYMAP and all its parents.
  See `keymap->map'."
  
negative.code:                                        (parents keymap)))))))
      (apply #'keymap->map (list-keymaps keymap '()))))
  
  (declaim (ftype (function (&rest keymap) (or keymap nil)) compose))
  (defun compose (&rest 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
  