anchor.diff:  
             (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))
  
positive.code:          (no-parse ()
             ,no-parse-form)))))
  
  (defmacro define-recursive-descent-parser (name &body body)
    (let (result-forms)
      (macrolet ((send (form) `(push ,form result-forms))
  
negative.code:                                  (return-from parse-recursive (parse-recursive ',production iter)))))
  
                      ((consp production)
                       (labels ((slot-name (thing)
                                  (if (consp thing) (car thing) thing)))
                         (dolist (thing production)
                           (unless (keywordp thing)
                             (push (slot-name thing) slots))))
                       (send-to the-body
                                `(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)))
  