anchor.diff:  
   (defmethod next ((pdurstutter pdurstutter-pstream))
     (with-slots (pattern n current-value current-repeats-remaining) pdurstutter
  -    (loop :while (and current-repeats-remaining
  -                      (zerop current-repeats-remaining))
  -          :do (setf current-repeats-remaining (next n))
  -              (let ((e (next pattern)))
  -                (when (and current-repeats-remaining
  -                           (not (zerop current-repeats-remaining)))
  -                  (setf current-value (ctypecase e
  -                                        (event (combine-events e (event :dur (/ (event-value e :dur) current-repeats-remaining))))
  -                                        (number (/ e current-repeats-remaining))
  -                                        (null nil))))))
  +    (while (and current-repeats-remaining
  +                (zerop current-repeats-remaining))
  +      (setf current-repeats-remaining (next n))
  +      (let ((e (next pattern)))
  +        (when (eop-p current-repeats-remaining)
  +          (return-from next eop))
  +        (when (and current-repeats-remaining
  +                   (not (zerop current-repeats-remaining)))
  +          (setf current-value (if (eop-p e)
  +                                  eop
  +                                  (ctypecase e
  +                                    (event (combine-events e (event :dur (/ (event-value e :dur) current-repeats-remaining))))
  +                                    (number (/ e current-repeats-remaining))))))))
       (when current-repeats-remaining
         (decf-remaining pdurstutter)
         current-value)))
  
positive.code:   (with-slots (pattern dur current-dur dur-history number) prun
      (let ((beats (beat (pattern-parent prun :class 'pbind))))
        (flet ((next-dur ()
                 (when-let ((nxt (next dur)))
                   (next pattern)
                   (incf current-dur nxt))))
          (when (= number 0)
            (next-dur))
          (while (and (or (not (pstream-p dur))
                          (not (ended-p dur)))
                      (<= current-dur beats))
            (next-dur))))
      (pstream-elt pattern -1)))
  
  ;;; psym
  
  
negative.code:                    :start-pos (pattern-as-pstream start-pos))))
  
  (defmethod next ((pwalk pwalk-pstream))
    (with-slots (list step-pattern direction-pattern start-pos current-index current-direction number) pwalk
      (when (zerop number)
        (setf current-index (next start-pos))
        (setf current-direction (next direction-pattern))
        (return-from next (nth current-index list)))
      (let ((nsp (next step-pattern)))
        (when (or (eop-p nsp) (eop-p current-index) (eop-p current-direction))
          (return-from next eop))
        (labels ((next-index ()
                   (+ current-index (* nsp current-direction))))
          (let ((next-index (next-index)))
            (when (or (minusp next-index)
                      (>= next-index (length list)))
              (setf current-direction (next direction-pattern)))
            (when (eop-p current-direction)
              (return-from next eop))
            (setf current-index (mod (next-index) (length list))))))
      (elt-wrap list current-index)))
  
  ;;; pparchain
  
  