anchor.diff:  
   Example:
   
  -;; (define-event-special-key amp ((:db (db-amp (raw-event-value event :db)))
  -;;                                (t 0.5))
  +;; (define-event-special-key :amp ((:db (db-amp (raw-event-value event :db)))
  +;;                                 (t 0.5))
   ;;   :define-methods t)
   
  -This defines the amp key for events. Since the :amp KEY is implied, it doesn't need to be specified in the CASES. Thus if the event already has an :amp key, its value will be used by default. If no :amp key exists in the event, then the :db FUNC is run if the :db key exists. If neither :amp nor :db exist in the event, then the t key is run, giving a default of 0.5.
  +This defines the amp key for events. Since the :amp key is implied, it doesn't need to be specified in the CASES. Thus if the event already has an :amp key, its value will be used by default. If no :amp key exists in the event, then the :db FUNC is run if the :db key exists. If neither :amp nor :db exist in the event, then the t key is run, giving a default of 0.5.
   
   Additionally, because :define-methods is true, we can also do the following:
   
  
positive.code: 
  ;;; timing
  
  (define-event-special-key timing-offset ((t 0)))
  
  (define-event-special-key quant ((:quant (ensure-list (raw-event-value event :quant)))
                                   (:play-quant (ensure-list (raw-event-value event :play-quant)))
                                   (t (list 1)))
    :define-methods t)
  
  (define-event-special-key play-quant ((:play-quant (ensure-list (raw-event-value event :play-quant)))
                                        (t (list 1)))
    :define-methods t)
  
  ;;; pitch
  
  (define-event-special-key freq ((:note (note-freq (event-value event :note)
                                                    :root (event-value event :root)
                                                    :octave (event-value event :octave)))
                                  (:midinote (midinote-freq (event-value event :midinote)))
                                  (:degree (degree-freq (event-value event :degree)
                                                        :root (event-value event :root)
                                                        :octave (event-value event :octave)
                                                        :scale (event-value event :scale)))
                                  (t 440))
    :remove-keys (:midinote :degree :root :octave)
    :define-methods t
    :documentation "Frequency of the note, in Hz.
  
  See also: `rate', `midinote', `degree'")
  
  (define-event-special-key note ((:freq (freq-note (event-value event :freq)
                                                    :root (event-value event :root)
                                                    :octave (event-value event :octave)
                                                    :scale (event-value event :scale)))
                                  (:midinote (midinote-note (event-value event :midinote)))
                                  (:degree (degree-note (event-value event :degree)
                                                        (event-value event :scale)))
                                  (t 0))
    :remove-keys (:freq :midinote :degree :root :octave)
    :documentation "Note number relative to the root.")
  
  (define-event-special-key midinote ((:freq (freq-midinote (event-value event :freq)))
                                      (:note (note-midinote (event-value event :note)
                                                            :root (event-value event :root)
                                                            :octave (event-value event :octave)))
                                      (:degree (degree-midinote (event-value event :degree)
                                                                :root (event-value event :root)
                                                                :octave (event-value event :octave)
                                                                :scale (event-value event :scale)))
                                      (t 69))
    :remove-keys (:freq :note :degree :root :octave)
    :define-methods t
    :documentation "MIDI note number of the note (0-127).")
  
  (define-event-special-key degree ((:freq (freq-degree (event-value event :freq)
                                                        :root (event-value event :root)
                                                        :octave (event-value event :octave)
                                                        :scale (event-value event :scale)))
                                    (:note (note-degree (event-value event :note)
                                                        (event-value event :scale)))
                                    (:midinote (midinote-degree (event-value event :midinote)
                                                                :root (event-value event :root)
                                                                :octave (event-value event :octave)
                                                                :scale (event-value event :scale)))
                                    (t 5))
    :remove-keys (:freq :note :midinote))
  
  (define-event-special-key root ((t 0)) ;; FIX: can we derive this when :freq, :midinote, :degree, etc are available?
    :remove-keys (:freq :note :midinote))
  
  (define-event-special-key octave ((:freq (freq-octave (raw-event-value event :freq)))
                                    (:midinote (midinote-octave (raw-event-value event :midinote)))
                                    (t 5))
    :remove-keys (:freq :note :midinote))
  
  (define-event-special-key scale ((t :major))
    :remove-keys (:freq :note :midinote)
    :define-methods t)
  
  (define-event-special-key base-freq ((:base-note (midinote-freq (event-value event :base-note)))
                                       (t 440)))
  
  (define-event-special-key base-note ((:base-freq (freq-midinote (event-value event :base-freq)))
                                       (t 69)))
  
  (define-event-special-key rate ((t (let ((res (multiple-value-list (event-value event :freq))))
                                       (values (freq-rate (car res) (event-value event :base-freq))
                                               (cadr res)))))
    ;; we don't do remove-keys because other frequency keys are not exact synonyms.
    ;; it's also conceivable that some instruments may use both :rate and :freq.
    :define-methods t
  
negative.code: (defun remove-event-value (event key)
    "Removes KEY from EVENT."
    (with-slots (event-plist) event
      (setf event-plist (remove-from-plist event-plist key)))
    event)
  
  (defun e (key)
  