anchor.diff:  
   (defun parse-assignment (lhs)
     (with-new-anchored-parse-tree (parse-tree-start-pos lhs) :set!
  -    (consume-token :identifier "=")
  +    (consume-token :punctuation "=")
       (list lhs (parse-expression))))
   
   ;; Precedence table:
  
positive.code:      (parse-lambda))
      ((tokenp :identifier "if") ; Handle branches.
       (parse-if))
      (t (right-assoc #'parse-assignment-term '((:punctuation "="))))))
  
  (defun right-assoc (sub-parser operators)
    (let ((start (funcall sub-parser)))
      (if (some (lambda (operator) (apply #'tokenp operator)) operators)
          (let ((operator (current-token)))
            (with-new-anchored-parse-tree
                (parse-tree-start-pos start) (list :prim0 (token-content operator))
              (next-token)
              (list start (right-assoc sub-parser operators))))
          start)))
  
  (defun parse-assignment-term ()
    (left-assoc #'parse-or-term '((:punctuation "||"))))
  
  (defun left-assoc (sub-parser operators)
    (labels ((iter (start)
  
negative.code:                  (parse-assignment expr)
                   expr)))))
  
  (defun tokenp (expected-type &optional expected-content)
    (let ((token (current-token)))
      (when token
        (let ((type (token-type token))
  