anchor.diff:                                   (return-from parse-recursive (parse-recursive ',production iter)))))
   
                       ((consp production)
  -                     (labels ((slot-name (thing) (if (consp thing) (car thing) thing)))
  +                     (labels ((slot-name (thing)
  +                                (if (consp thing) (car thing) thing)))
                          (dolist (thing production)
  -                         (push (slot-name thing) slots)))
  +                         (unless (keywordp thing)
  +                           (push (slot-name thing) slots))))
                        (send-to the-body
  -                              `(try-parse ((iter iter))
  -                                 (let ((instance (make-instance ',nonterm-name))
  -                                       matches)
  -                                   (dolist (thing ',production)
  -                                     (unless (consp thing)
  -                                       (setf thing (cons thing thing)))
  -                                     (let ((match (parse-recursive (cdr thing) iter)))
  -                                       (setf (slot-value instance (car thing)) match)
  -                                       (push match matches)))
  -                                   (setf (slot-value instance 'raw-matches) (nreverse matches))
  -                                   (return-from parse-recursive instance)))))))
  +                              `(let (strict)
  +                                 (try-parse ((iter iter)
  +                                             :no-parse-form (when strict
  +                                                              (abort-parse "Oh no")))
  +                                   (let ((instance (make-instance ',nonterm-name))
  +                                         matches)
  +                                     (dolist (thing ',production)
  +                                       (block continue
  +                                         (when (eq :strict thing)
  +                                           (setf strict t)
  +                                           (return-from continue))
  +                                         (unless (consp thing)
  +                                           (setf thing (cons thing thing)))
  +                                         (let ((match (parse-recursive (cdr thing) iter)))
  +                                           (setf (slot-value instance (car thing)) match)
  +                                           (push match matches))))
  +                                     (setf (slot-value instance 'raw-matches) (nreverse matches))
  +                                     (return-from parse-recursive instance))))))))
   
                   (when slots
                     (let ((unique-slots (make-hash-table)))
  
positive.code:          (keywordp (car form))))
  
    (defun grammar-lookup-option (option-name options)
      (second (find option-name options :key #'car :test #'eq))))
  
  (defclass syntax-tree ()
    ((raw-matches
  
negative.code: 
            (unless (and start-symbol terminals)
              (error "Start symbol and terminals are required"))
  
            (when (left-recursion-p nonterminals)
              (error "Grammar has left recursion ~A" (left-recursion-p nonterminals)))
  
            ;; Easiest stuff first.  The root node
            (send `(defmethod parse-recursive ((type (eql ',name)) (iter lookahead-iterator))
  