anchor.diff:      (loop
          while (parse-state-tokens *parse-state*)
          do (push (parse-statement) result))
  -    result))
  +    (reverse result)))
   
   (defun parse-statement ()
     (cond ((tokenp :punctuation "{")
  
positive.code:       (reverse statements))))
  
  (defun consume-token (type content)
    (require-token type content)
    (next-token))
  
  (defun require-token (type content)
    (let ((token (current-token)))
      (unless (and token (tokenp type content))
        (if token
            (let ((start-pos (token-start-pos token)))
              (error
               "Shovel parse error at line ~d column ~d: expected '~a' but got '~a'."
               (pos-line start-pos)
               (pos-column start-pos)
               content
               (token-content token)))
            (error
             "Shovel parse error: expected '~a' but reached the end of input."
             content)))))
  
  (defun parse-var-decl ()
    (with-new-parse-tree :var
  
negative.code: 
  (defun parse-assignment (lhs)
    (with-new-anchored-parse-tree (parse-tree-start-pos lhs) :set!
      (consume-token :punctuation "=")
      (list lhs (parse-expression))))
  
  ;; Precedence table:
  