anchor.diff:                   (let* ((cweights (cumulative-list (normalized-sum weights)))
                           (num (random 1.0))
                           (res (nth (index-of-greater-than num cweights) list)))
  -                   (when (not (null (slot-value pattern 'history)))
  +                   (unless (null (slot-value pattern 'history))
                        (loop :while (eql res (pstream-nth -1 pattern))
                           :do (setf res (get-next))))
                      res)))
  
positive.code:             (cdur (reduce #'+ dur-history)))
          (loop :while (and (ok) (<= cdur beats))
             :do
             (let ((nxt (next dur)))
               (alexandria:appendf dur-history (list nxt))
               (when nxt
                 (incf cdur nxt))))
          (when (ok)
            (let* ((clist (cumulative-list dur-history))
                   (idx (or (index-of-greater-than beats clist) 0)))
  
negative.code:                   (unless (typep pattern 'pbind)
                      (alexandria:appendf pattern-chain (list pattern))
                      (setf pattern (make-instance 'pbind)))
                    (alexandria:appendf res-pairs (list key (if (and (eql key :embed)
                                                                     (typep value 'symbol))
                                                                (pdef value)
                                                                value)))))))
      (unless (null res-pairs)
        (setf (slot-value pattern 'pairs) res-pairs))
      (alexandria:appendf pattern-chain (list pattern))
      (unless (alexandria:length= 1 pattern-chain)
        (setf pattern (apply #'pchain pattern-chain)))
      ;; process :quant key. ;; FIX: should this be applied to the pdef, or the pattern itself?
      (alexandria:when-let ((quant (getf pairs :quant)))
  