anchor.diff:  (import string)
   (import urn/logger logger)
   (import function (cut))
  +
  +(defun hex-digit? (char)
  +  "Determines whether CHAR is a hecharadecimal digit"
  +  (or (between? char "0" "9") (between? char "a" "f") (between? char "A" "F")))
  +
  +(defun bin-digit? (char)
  +  "Determines whether char is a binary digit"
  +  (or (= char "0") (= char "1")))
  +
  +(defun terminator? (char)
  +  "Determines whether CHAR is a terminator of a block"
  +  (or (= char "\n") (= char " ") (= char "\t") (= char "(") (= char ")") (= char "[") (= char "]") (= char "{") (= char "}") (= char "")))
   
   (defun lex (str name)
     (let* ((lines (string/split str "\n"))
  
positive.code:             (let ((start (position))
                    (tag (if (= char ":" ) "key" "symbol")))
                (set! char (string/char-at str (succ offset)))
                (while (and (/= char "\n") (/= char " ") (/= char "\t") (/= char "(") (/= char ")") (/= char "[") (/= char "]") (/= char "{") (/= char "}") (/= char ""))
                  (consume!)
                  (set! char (string/char-at str (succ offset))))
                (append! tag start))))
  
negative.code:          (out '())
           ;; Consumes a single symbol and increments the position
           (consume! (lambda ()
                       (if (= (string/char-at str offset) "\n")
                         (progn
                           (inc! line)
                           (set! column 1))
                         (inc! column))
                       (inc! offset)))
            ;; Generates a table with the current position
           (position (lambda () (struct :line line :column column :offset offset)))
           ;; Generates a table with a particular range
           (range (lambda (start finish) (struct :start start :finish (or finish start) :lines lines :name name)))
           ;; Appends a struct to the list
           (append-with! (lambda (data start finish)
                           (let ((start (or start (position)))
                                  (finish (or finish (position))))
                             (.<! data :range (range start finish))
                             (.<! data :contents (string/sub str (.> start :offset) (.> finish :offset)))
                             (push-cdr! out data))))
           ;; Appends a token to the list
           (append! (lambda (tag start finish)
                      (append-with! (struct :tag tag) start finish)))
           (parse-base (lambda (name p base)
                         (let* [(start offset)
                                (char (string/char-at str offset))]
                           ;; Require at least one character
                           (unless (p char)
                             (with (pos (range (position)))
                               (logger/print-error! (string/format "Expected %s digit, got %s" name (if (= char "")
                                                                                                      "eof"
                                                                                                      (string/quoted char))))
                               (logger/put-trace! pos)
                               (logger/put-lines! false
                                 pos  "Invalid digit here")))
  
                           ;; Consume all remaining characters matching this
                           (set! char (string/char-at str (succ offset)))
                           (while (p char)
                             (consume!)
                             (set! char (string/char-at str (succ offset))))
  
                           ;; And conver the digit to a string
                           (string->number (string/sub str start offset) base)))))
      ;; Scan the input stream, consume one character, then reading til the end of that token.
      (while (<= offset length)
        (with (char (string/char-at str offset))
  