anchor.diff:                   (slot-boundp pattern slot))
           (set-parent (slot-value pattern slot) pattern)))))
   
  -(defmethod initialize-instance :before ((pattern pattern) &key)
  +(defmethod initialize-instance :after ((pattern pattern) &key)
     (set-parents pattern))
   
   (defun pattern-p (object)
  
positive.code: (defmethod peek ((pattern pattern))
    (next (as-pstream pattern)))
  
  (defmethod next :around ((pstream pstream))
    (labels ((get-value-from-stack (pattern)
               (with-slots (number pattern-stack) pattern
                 (if pattern-stack
                     (let ((popped (pop pattern-stack)))
                       (let ((nv (next popped)))
                         (if (eop-p nv)
                             (get-value-from-stack pattern)
                             (progn
                               (push popped pattern-stack)
                               nv))))
                     (prog1
                         (let ((res (call-next-method)))
                           (typecase res
                             (pattern
                              ;; if `next' returns a pattern, we push it to the pattern stack as a pstream
                              (let ((pstr (as-pstream res)))
                                (setf (slot-value pstr 'start-beat) (beat pattern))
                                (push pstr pattern-stack))
                              (get-value-from-stack pattern))
                             (t res)))
                       (incf number))))))
      (with-slots (number history history-number future-number) pstream
  
negative.code:          (name (class-name class))
           (slots (remove 'parent (mapcar #'closer-mop:slot-definition-name (closer-mop:class-slots class)))))
      (apply #'make-instance
             (intern (concat name '-pstream) (symbol-package name))
             (mapcan (fn (when (slot-boundp pattern _)
                           (list (make-keyword _)
                                 (pattern-as-pstream (slot-value pattern _)))))
                     slots))))
  
  (defmethod as-pstream :around ((object t))
    (let ((pstream (call-next-method)))
  