anchor.diff:    (make-iterator (:type 'syntax-iterator)
       (try-parse (iter token-iterator)
           (lambda (message) (error 'abort-parse :message message))
  -      (parse grammar iter))))
  +      (let ((value (parse grammar iter)))
  +        (when (eq 'eof-hit value)
  +          (stop))
  +        (emit value)))))
  
positive.code:           ;; Now parsers for the terminals
            (dolist (term terminals)
              (send `(defmethod parse ((type (eql ',term)) (iter token-iterator))
                       (unless (typep (peek-lookahead-iterator iter) ',term)
                         (no-parse "Token mismatch" ',term))
                       (next iter))))
  
            ;; Now the nonterminals
  
negative.code:               (let (the-body
                      hit-epsilon
                      slots)
  
                  (when (eq nonterm-name start-symbol)
                    (send-to the-body
                             `(multiple-value-bind (value more) (peek-lookahead-iterator iter)
                                (declare (ignore value))
                                (unless more
                                  (return-from parse 'eof-hit)))))
  
                  (dolist (production productions)
                    (cond
                      (hit-epsilon
  