anchor.diff:                                  (res (funcall func value pattern)))
              (setf (slot-value pbind 'pairs) (plist-set (slot-value pbind 'pairs) key nil))
              (setf pattern res))))
  +    ;; process :quant key. ;; FIX: should this be applied to the pdef, or the pattern itself?
  +    (alexandria:when-let ((quant (getf pairs :quant)))
  +      (setf (quant pattern)
  +            (if (functionp quant)
  +                (funcall quant)
  +                quant)))
       ;; process :pdef key.
       (alexandria:when-let ((pos (position :pdef (keys pairs))))
         (pdef (nth (1+ pos) pairs) pattern))
  
positive.code:            (lambda (value pattern)
               (declare (ignorable value pattern))
               ,@body))))
  
  (define-pbind-special-init-key quant
    (setf (slot-value pattern 'quant)
          (if (functionp value)
              (funcall value)
              value))
    (list :quant value))
  
  (define-pbind-special-init-key remaining
    (setf (slot-value pattern 'remaining) (next value))
  
negative.code: 
  (defclass pattern ()
    ((remaining :initarg :remaining :initform :inf)
     (quant :initarg :quant :initform (list 1) :reader quant) ;; quant, phase, timing-offset
     (parent :initarg :parent :initform nil)
     (loop-p :initarg :loop-p :initform nil :accessor loop-p)
     (cleanup-functions :initarg :cleanup-functions :initform (list)))
    (:documentation "Abstract pattern superclass."))
  
  (defmethod (setf quant) (value (pattern pattern))
    (setf (slot-value pattern 'quant) (alexandria:ensure-list value)))
  
  (defgeneric next (pattern)
    (:documentation "Returns the next value of a pattern stream, function, or other object, advancing the pattern forward in the process.
  