anchor.diff:     int
      (|(| expression |)| #'k-2-3)))
   
  -(defun parse-left-expression (e)
  -  (with-input-from-string (s e)
  -    (parse-with-lexer #'(lambda () (simple-lexer s))
  -                      *left-expression-parser*)))
  -
  -(define-parser *precedence-expression-parser*
  +(define-parser *precedence-left-expression-parser*
     (:start-symbol expression)
     (:terminals (int id + - * / |(| |)|))
     (:precedence ((:left * /) (:left + -)))
  
positive.code:    int
     (|(| expression |)| #'k-2-3)))
  
  (defun parse-precedence-expression (e)
    (with-input-from-string (s e)
      (parse-with-lexer #'(lambda () (simple-lexer s))
                        *precedence-expression-parser*)))
  
  (defun tests-hi ()
    (let ((*package* (find-package '#:yacc-tests)))
      (dolist (e '("5/3*(12+foo)/3+foo"))
          (parse-left-expression e)
          (parse-precedence-expression e))
      (dolist (e '("5/3*(" "5/3)"))
        (expect-condition yacc-parse-error
          (parse-left-expression e))
        (expect-condition yacc-parse-error
          (parse-precedence-expression e))))
    t)
  
  (defun tests ()
  
negative.code: 
  (in-package #:yacc-tests)
  
  (defmacro expect (form expected)
    (let ((value (gensym "VALUE")))
      `(let ((,value ,form))
        (unless (equal ,value ,expected)
          (error "Test failed: ~S yielded ~S, expected ~S"
                 ',form ,value ,expected)))))
  
  (defmacro expect-condition (class &body body)
    (let ((name (gensym "EXPECT-CONDITION")))
    `(block ,name
  