anchor.diff:                     :list (next list)
                      :repeats repeats
                      :sl (alexandria:shuffle (alexandria:copy-sequence 'list list))
  -                   :crr repeats)))
  +                   :crr (next repeats))))
   
   (defmethod next ((pattern pshuf-pstream))
     (with-slots (number sl) pattern
  
positive.code:   ((lo :initarg :lo)
     (hi :initarg :hi)
     (step :initarg :step)
     (cv :initarg :cv :initarg :cv)))
  
  (defun pbrown (&optional (lo 0) (hi 1) (step 0.125) (remaining :inf))
    (make-instance 'pbrown
                   :lo lo
                   :hi hi
                   :step step
                   :cv (random-range lo hi)
                   :remaining remaining))
  
  (defmethod next ((pattern pbrown-pstream))
    (with-slots (step cv lo hi) pattern
      (let ((nstep (next step)))
        (incf cv (random-range (* -1 nstep) nstep)))
      (setf cv (alexandria:clamp cv (next lo) (next hi)))
      cv))
  
  ;;; pseries
  
  
negative.code: 
  (defpattern pwhite (pattern)
    ((lo :initarg :lo)
     (hi :initarg :hi)
     (length :initarg :length)
     (crr :initarg :crr :initform nil)))
  
  (defun pwhite (&optional (lo 0) (hi 1) (length :inf))
    (make-instance 'pwhite
                   :lo lo
                   :hi hi
                   :length length))
  
  (defmethod as-pstream ((pattern pwhite))
    (with-slots (lo hi length) pattern
      (make-instance 'pwhite-pstream
                     :lo lo
                     :hi hi
                     :length length
                     :crr (next length))))
  
  (defmethod next ((pattern pwhite-pstream))
    (when (remainingp pattern 'crr)
      (decf-remaining pattern 'crr)
      (random-range (next (slot-value pattern 'lo)) (next (slot-value pattern 'hi)))))
  
  ;;; pbrown
  ;; FIX: maybe should coerce lo, hi, and step to floats if one of them is a float?
  