anchor.diff:                                                                char))
                       (range (position)) nil
                       (range (position)) "Illegal character here. Are you missing whitespace?")))))
  -          ((= char "\"")
  +          [(= char "\"")
               (let* [(start (position))
                      (start-col (succ column))
                      (buffer '())]
  
positive.code: 
                (with (val (cond
                             ;; Parse hexadecimal digits
                             ((and (= char "#") (= (string/lower (string/char-at str (succ offset))) "x"))
                               (consume!)
                               (consume!)
                               (with (res (parse-base "hexadecimal" hex-digit? 16))
                                 (when negative (set! res (- 0 res)))
                                 res))
                             ;; Parse binary digits
                             ((and (= char "#") (= (string/lower (string/char-at str (succ offset))) "b"))
                               (consume!)
                               (consume!)
                               (with (res (parse-base "binary" bin-digit? 2))
                                 (when negative (set! res (- 0 res)))
                                 res))
                             (true
                               ;; Parse leading digits
                               (while (between? (string/char-at str (succ offset))  "0" "9")
                                 (consume!))
  
                               ;; Consume decimal places
                               (when (= (string/char-at str (succ offset)) ".")
                                 (consume!)
                                 (while (between? (string/char-at str (succ offset))  "0" "9")
                                   (consume!)))
  
                               ;; Consume exponent
                               (set! char (string/char-at str (succ offset)))
                               (when (or (= char "e") (= char "E"))
                                 (consume!)
                                 (set! char (string/char-at str (succ offset)))
  
                                 ;; Gobble positive/negative bit
                                 (when (or (= char "-") (= char "+")) (consume!))
  
                                 ;; And exponent digits
                                 (while (between? (string/char-at str (succ offset)) "0" "9")
                                   (consume!)))
  
                               (string->number (string/sub str (.> start :offset) offset)))))
                  (append-with! {:tag "number" :value val} start)
  
                  ;; Ensure the next character is a terminator of some sort, otherwise we'd allow things like 0x2-2
  
negative.code:         ;; Attempt to find mismatched indents. This both highlights formatting errors and helps find the source of
          ;; parse errors due to mismatched parentheses.
          ;; To do this we store a reference to the first node on the previous line and check if the indent is different.
          (let [(previous (.> head :last-node))
                (tok-pos (.> tok :range))]
            ;; This catches a couple of trivial cases:
            ;;  - Closing parentheses. As lisp doesn't use C style indentation for brackets, the closing one will be on a
            ;;    different line.
  