anchor.diff:                                (1+ (start scanner))
                                 (1- (current scanner))))))
   
  -    (loop until (or (char= (peek scanner) #\")
  -                    (is-at-end scanner))
  -          do (advance scanner))
  -
  -    ;; If String's not terminated
  -    (if (is-at-end scanner)
  -        ;; Report it
  -        (cerror "Continue scanning"
  -                'unterminated-string-error
  -                :line (line scanner)
  -                :place (start scanner))
  -        ;; Consume the closing "
  -        (advance scanner))
  -    (add-string scanner)))
  +    ;; Only process the string if it starts as a string
  +    (when (char= (current-character scanner) #\")
  +      (loop until (or (char= (peek scanner) #\")
  +                      (is-at-end scanner))
  +            do (advance scanner))
  +
  +      ;; If String's not terminated
  +      (if (is-at-end scanner)
  +          ;; Report it
  +          (cerror "Continue scanning"
  +                  'unterminated-string-error
  +                  :line (line scanner)
  +                  :place (start scanner))
  +          ;; Otherwise consume the closing "
  +          (advance scanner))
  +      (add-string scanner))))
   
   (-> is-digit (character) boolean)
   (defun is-digit (char)
  
positive.code: (-> match (scanner character) boolean)
  (defun match (scanner expected)
    "Consume the next character and return T if it is expected character, return NIL otherwise."
    (unless (or (is-at-end scanner)
                (char/= (current-character scanner) expected))
      (move-forward scanner)
      t))
  
  (-> peek (scanner) character)
  (defun peek (scanner)
    "Return the next character in the source or NUL if we're at the end."
    (if (is-at-end scanner)
        #\Nul
        (current-character scanner)))
  
  (-> peek-next (scanner) character)
  (defun peek-next (scanner)
    "Return the character after the next character in the source or NUL if there's none.'"
    (if (>= (1+ (current scanner))
            (length (source scanner)))
        #\Nul
        (aref (source scanner)
              (1+ (current scanner)))))
  
  (-> scan-token (scanner) null)
  (defun scan-token (scanner)
    "Add next token from the scanner's source."
    (let ((currently-processed-character (advance scanner)))
      (case currently-processed-character
        ;; One-character tokens
        (#\( (add-token scanner :left-paren))
        (#\) (add-token scanner :right-paren))
        (#\{ (add-token scanner :left-brace))
        (#\} (add-token scanner :right-brace))
        (#\, (add-token scanner :comma))
        (#\. (add-token scanner :dot))
        (#\- (add-token scanner :minus))
        (#\+ (add-token scanner :plus))
        (#\; (add-token scanner :semicolon))
        (#\* (add-token scanner :star))
  
        ;; One-Or-Two-character tokens
        (#\! (add-token scanner (if (match scanner #\=)
                                    :bang-equal
                                    :bang)))
        (#\= (add-token scanner (if (match scanner #\=)
                                    :equal-equal
                                    :equal)))
        (#\< (add-token scanner (if (match scanner #\=)
                                    :less-equal
                                    :less)))
        (#\> (add-token scanner (if (match scanner #\=)
                                    :greater-equal
                                    :greater)))
  
        ;; Process Comments
        (#\/ (if (match scanner #\/)
                 (process-single-line-comment scanner)
                 (add-token scanner :slash)))
  
        ;; Ignore whitespace. Newline is processed automatically when moving position
        ((#\Space #\Tab #\Return #\Linefeed) nil)
  
        ;; Strings
        (#\" (process-string scanner))
  
        (otherwise
         (cond
           ((is-digit currently-processed-character) (process-number-literal scanner))
           ((is-alpha currently-processed-character) (process-identifier scanner))
           (t (cerror "Continue scanning."
                      'unexpected-character-error
                      :character currently-processed-character
                      :line (line scanner)
                      :place (start scanner)))))))
    nil)
  
  (-> scan-tokens (string) vector)
  (defun scan-tokens (input)
  
negative.code:                      (add-token scanner :eof)
                       (tokens scanner)))))
  
  (-> add-token (scanner token-type &optional t) token)
  (defun add-token (scanner token-type &optional literal)
    "Add token to the vector of scanned tokens."
    (let ((token (make-instance'token :type token-type
                                      :lexeme (subseq (source scanner)
                                                      (start scanner)
                                                      (current scanner))
                                      :literal literal
                                      :line (line scanner))))
      (vector-push-extend token (tokens scanner))
      token))
  
  
  (-> process-1char-token (scanner) (or null token))
  (defun process-1char-token (scanner)
    (loop
      ;; Potential optimization: create a case form
      ;; at a read-time to save looping
      with currently-processed-character = (current-character scanner)
      for (potential-char potential-token) in +1char-token-associations+
      if (char= potential-char currently-processed-character) return (add-token scanner potential-token)))
  
  (-> process-1-or-2-char-token (scanner) (or null token))
  (defun process-1-or-2-char-token (scanner)
    (loop
      ;; Potential optimization: create a case form
      ;; at a read-time to save looping
      with currently-processed-character = (current-character scanner)
      for ((first-char 1-token-name)
           (second-char 2-token-name))
        in +1-or-2-char-token-associations+
      if (char= currently-processed-character first-char)
        if (match scanner second-char)
          return (add-token scanner 2-token-name)
      ;; this else is for the second if, not the first one
      else return (add-token scanner 1-token-name)))
  
  (-> process-comment-or-slash (scanner) (or null token))
  (defun process-comment-or-slash (scanner)
    (if (char= (current-character scanner) #\/)
        (if (match scanner #\/)
            (process-single-line-comment scanner)
            (add-token scanner :slash))))
  
  (-> process-whitespace (scanner) boolean)
  (defun process-whitespace (scanner)
    (some (alexandria:curry #'char= (current-character scanner))
          (list #\Space #\Tab #\Return #\Linefeed)))
  
  (-> process-single-line-comment (scanner) boolean)
  (defun process-single-line-comment (scanner)
    "Consume contents of until EOL or EOF."
    (loop until (or (is-at-newline scanner)
                    (is-at-end scanner))
          do (advance scanner))
    t)
  
  (-> process-string (scanner) (or null token))
  (defun process-string (scanner)
    "Consume the string from the current point to the closing double quote."
    (flet ((add-string (scanner)
  