anchor.diff:    nil)
   
   (defun serialize-key-chord (key-chord &key normalize)
  -  ;; TODO: Make use of keycode?
  -  ;; TODO: Case opposite to Caps-Lock status?
     "When NORMALIZE is non-nil, remove the shift modifier and upcase the keys."
     (let ((modifiers (copy-list (key-chord-modifiers key-chord))))
       (when (and normalize
  
positive.code: 
  (defun key (key-sequence-string)
    "Turn KEY-SEQUENCE-STRING into a sequence of serialized key-chords.
  The return value is a list of strings.  The KEY-SEQUENCE-STRING is in the form
  of \"C-x C-s\".
  
  Firstly, we break it apart into chords: \"C-x\" and \"C-s\".  Then, we break
  apart the chords into individual keys.  We use those individual keys to create a
  `key' struct that describes the chord.  We now have two `key's.  We connect
  these two keys in a list in reverse (<key C-s> <key C-x>) to
  match (key-chord-stack *interface*).
  
  This can serve as the key in the keymap."
    (serialize-key-chord-stack
     (nreverse
      ;; Iterate through all key chords (space delimited)
  
negative.code:   (mapcar (lambda (k) (serialize-key-chord k :normalize normalize))
            key-chord-stack))
  
  (defun stringify (serialized-key-stack)
    "Return string representation of a serialized key-chord stack.
     E.g. print ((nil - C) (nil x C)) as \"C-x C--\". This is
     effectively the inverse of `serialize-key-chord-stack'."
    (format nil "~{~a~^ ~}"
            (mapcar (lambda (serialized-key-chord)
                      (format nil "~{~a~^-~}"
  