anchor.diff:                              (digit-error! logger (range (position)) "roman" char))
                             ; consume the rest
                             (set! char (string/char-at str (succ offset)))
  -                          (while (roman-digit? char)
  +                          (while (or (roman-digit? char)
  +                                     (= char "'")) ; thousands separator
                               (consume!)
                               (set! char (string/char-at str (succ offset))))
                             ; now this is a hack
  -                          (let* [(str (string/reverse (string/sub str start offset)))]
  +                          (let* [(str (apply .. (string/split (string/reverse (string/sub str start offset))
  +                                                              "'")))]
                               ; This implementation was stolen and adapted from
                               ; the Rosetta code entry for decoding Roman numerals
                               ; in Scheme.
  
positive.code:                               (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:                                hexadecimal and roman numbers."
                                (range (position)) "# must be followed by x, b or r")]
                             [true
                              (print! "decimal")
                              ;; Parse leading digits
                              (while (or (between? (string/char-at str (succ offset))  "0" "9")
                                         (= (string/char-at str (succ offset)) "'")) ; thousands separator
                                (consume!))
  
                              ;; Consume decimal places
                              (when (= (string/char-at str (succ offset)) ".")
                                (consume!)
                                (while (or (between? (string/char-at str (succ offset))  "0" "9")
                                           (= (string/char-at str (succ offset)) "'")) ; thousands here too
                                  (consume!)))
  
                              ;; Consume exponent
  