anchor.diff:  
                            ;; Consume all remaining characters matching this
                            (set! char (string/char-at str (succ offset)))
  -                         (while (p char)
  +                         (while (or (p char)
  +                                    (= "'" char)) ; thousands separator
                              (consume!)
                              (set! char (string/char-at str (succ offset))))
   
  -                         ;; And convert the digit to a string
  -                         (string->number (string/sub str start offset) base))))]
  +                         (let* [(thousands-separated (apply .. (string/split (string/sub str start offset)
  +                                                                             "'")))]
  +                           ;; And convert the digit to a string
  +                           (string->number thousands-separated base)))))]
       ;; Scan the input stream, consume one character, then read til the end of that token.
       (while (<= offset length)
         (with (char (string/char-at str offset))
  
positive.code:                                hexadecimal and roman numbers."
                                (range (position)) "# must be followed by x, b or r")]
                             [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
  
negative.code:                               (when (or (= char "-") (= char "+")) (consume!))
  
                                ;; And exponent digits
                                (while (or (between? (string/char-at str (succ offset))  "0" "9")
                                           (= (string/char-at str (succ offset)) "'")) ; thousands here too
                                  (consume!)))
  
                              (string->number (apply .. (string/split (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
  