anchor.diff:     (start :initarg :start :reader array-context-start)
      (end :initarg :end :reader array-context-end))
     (:documentation "specialization for parsing an array of tokens"))
  +
  +(defgeneric make-context (type &key gensym chain))
  +
  +(defmethod make-context ((type (eql 'string-context)) &key gensym chain)
  +  (declare (ignore type))
  +  (make-instance
  +   'string-context
  +   :string (cond
  +             (chain
  +              (slot-value chain 'string))
  +             (gensym
  +              (gensym (symbol-name :string-)))
  +             (t 'string))
  +   :start (cond
  +            ;; how to chain? usually want to start with previous rule's end?
  +            (gensym
  +             (gensym (symbol-name :start-)))
  +            (t 'start))
  +   :end (cond
  +          (chain
  +           (slot-value chain 'end))
  +          (gensym
  +           (gensym (symbol-name :end-)))
  +          (t 'end))))
   
   ;; print a warning when a form is not recognized
   ;; in (parse form), form may be incorrect; mark as (parse (cl form)) if intentional
  
positive.code:     (return-from cpf-list (slot-value context 'start)))
    (with-slots (string start end) context
      (let* ((args (cdr form))
             (blocksym (gensym (symbol-name :and-)))
             (endsym (gensym (symbol-name :end-)))
             (valsym (gensym (symbol-name :val-)))
             (listsym (gensym (symbol-name :list-)))
             (tailsym (gensym (symbol-name :tail-)))
             (new-context
              (make-instance 'string-context
                             :string string
                             :start endsym
                             :end end))
             (inner
              `(let* ((,endsym ,start)
                      ,valsym
  
negative.code:       (pushback `(values ,endsym (cdr ,listsym))
                  last)
        `(block ,blocksym ,inner))))
  
  
  (defrule test-and0 (and "hi" (and)))
  
  