anchor.diff:  (define-event-special-key delta (:dur (event-value event :dur)
                                         t (event-value event :dur))
     :remove-keys nil
  -  :define-methods t)
  +  :define-methods t
  +  :documentation "The number of beats between the start of this event and the start of the next one.
  +
  +See also: `dur', `sustain'")
   
   (define-event-special-key dur (:delta (raw-event-value event :delta)
                                         t 1)
     :remove-keys nil
  -  :define-methods t)
  +  :define-methods t
  +  :documentation "The total duration of the note, in beats.
  +
  +See also: `delta', `legato'")
   
   ;; sustain/legato
   
   (define-event-special-key sustain (t (* (event-value event :legato)
                                           (event-value event :dur)))
     :remove-keys (:legato)
  -  :define-methods t)
  +  :define-methods t
  +  :documentation "How long the note should be held, in beats.
  +
  +See also: `legato', `delta'")
   
   (define-event-special-key legato (:sustain (* (raw-event-value event :sustain)
                                                 (event-value event :dur))
  -                                           t 0.8)
  +                                  t 0.8)
     :remove-keys (:sustain)
  -  :define-methods t)
  +  :define-methods t
  +  :documentation "How long the note should be held, in beats, as a factor of its total duration (`dur').
  +
  +See also: `sustain', `dur'")
   
   ;;; timing
   
   (define-event-special-key timing-offset (t 0))
   
   (define-event-special-key quant (:quant (ensure-list (raw-event-value event :quant))
  -                                        t (list 1))
  +                                 t (list 1))
     :define-methods t)
   
   ;;; pitch
  
positive.code:                                                          :octave (event-value event :octave)
                                                           :scale (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 :midinote)
    :define-methods t)
  
  (define-event-special-key root (t 0) ;; FIX: can we derive this when :freq, :midinote, :degree, etc are available?
    :remove-keys (:freq :midinote)
    :define-methods t)
  
  (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 :midinote)
    :define-methods t)
  
  (define-event-special-key scale (t :major)
    :remove-keys (:freq :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))))
    :define-methods t)
  
negative.code:                                                       (list ,@(ensure-list remove-keys)))))
         ,(when define-methods
            `(progn
               ,(when documentation
                  `(defgeneric ,name (object)
                     (:documentation ,documentation)))
               (defmethod ,name ((event null)) nil)
               (defmethod ,name ((event event))
                 (event-value event ,kwname))
  