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:                               (slot-value object 'pstream-count)
                                0)
              source object))
      pstream))
  
  (defmethod as-pstream :around ((pstream pstream)) ;; prevent pstreams from being "re-converted" to pstreams
    pstream)
  
  (define-condition pstream-out-of-range () ((index :initarg :index :reader pstream-elt-index))
  
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)))
  