anchor.diff:    (or (is-alpha char)
         (is-digit char)))
   
  -(-> process-number-literal (scanner) null)
  +;; TODO: Add .123 format
  +(-> process-number-literal (scanner) (or token null))
   (defun process-number-literal (scanner)
     "Process a number literal and return T, or return NIL and don't process anything if the token isn't number literal."
  -  (loop while (is-digit (peek scanner)) do (advance scanner))
  -  (when (and (char= (peek scanner) #\.)
  -             (is-digit (peek-next scanner)))
  -    ;; Consume the dot
  -    (advance scanner)
  -    (loop while (is-digit (peek scanner)) do (advance scanner)))
  -  (add-token scanner :number (read-from-string
  -                              (subseq (source scanner)
  -                                      (start scanner)
  -                                      (current scanner)))))
  -
  -(-> process-identifier (scanner) null)
  +  (when (or (is-digit (current-character scanner)))
  +
  +    (loop while (is-digit (peek scanner)) do (advance scanner))
  +
  +    ;; Check if the number is a floating point one
  +    (when (and (char= (peek scanner) #\.)
  +               (is-digit (peek-next scanner)))
  +      ;; Consume the dot
  +      (advance scanner)
  +      ;; And collect the rest
  +      (loop while (is-digit (peek scanner)) do (advance scanner)))
  +
  +    (add-token scanner :number (read-from-string
  +                                (subseq (source scanner)
  +                                        (start scanner)
  +                                        (current scanner))))))
  +
  +(-> process-identifier (scanner) (or token null))
   (defun process-identifier (scanner)
  -  (loop while (is-alphanumeric (peek scanner)) do (advance scanner))
  -  (add-token scanner
  -             (gethash
  -              (subseq (source scanner) (start scanner) (current scanner))
  -              +keywords+
  -              :identifier)))
  +  "Return TOKEN if it is an identifier, NIL otherwise."
  +  (when (is-alpha (current-character scanner)) ; valid identifier starts with an alphabet character.
  +    (loop while (is-alphanumeric (peek scanner)) do (advance scanner))
  +    (add-token scanner
  +               (gethash
  +                (subseq (source scanner) (start scanner) (current scanner))
  +                +keywords+
  +                :identifier))))
  
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: ;; Defining Token
  ;; ;;;;;;;;;;;;;;
  
  (eval-when (:compile-toplevel :load-toplevel :execute)
    (defparameter +1char-token-associations+
      ;; Format:
      ;; List of 2-element lists, where the first element is a character
      ;; and second element is the token name.
      ;; ((char token-name) ...)
      ;; A character is a character and a token name is a keyword symbol.
      '((#\( :left-paren)
        (#\) :right-paren)
        (#\{ :left-brace)
        (#\} :right-brace)
        (#\, :comma)
        (#\. :dot)
        (#\- :minus)
        (#\+ :plus)
        (#\* :star)
        (#\/ :slash)
        (#\? :question-mark)
        (#\: :colon)
        (#\; :semicolon)))
  
    (defparameter +1-or-2-char-token-associations+
      ;; Format:
      ;; List of 2 2-element lists, first list being indicating the first character and token name for single character token,
      ;; Second list having the second character and indicating the 2-character token name:
      ;; ((first-char 1char-token-name) (second-char 2char-token-name) ...)
      ;; A character is a character and token name is a keyword symbol
      '(((#\! :bang) (#\= :bang-equal))
        ((#\= :equal) (#\= :equal-equal))
        ((#\> :greater) (#\= :greater-equal))
        ((#\< :less) (#\= :less-equal))))
  
    (defparameter +literals+
      ;; Format:
      ;; List of token names
      ;; (token1 token2 ...)
      ;; Token names are keyword symbols.
      '(:identifier :string :number))
  
    (defparameter +keywords-alist+
      ;; Format: association list of lexeme(token) and token name pairs (dotted lists)
      ;; ((lexeme . token-name) ...)
      ;; Lexeme is a string, token name is a keyword symbol.
      '(("and" . :and)
        ("class" . :class)
        ("else" . :else)
        ("false" . :false)
        ("for" . :for)
        ("fun" . :fun)
        ("if" . :if)
        ("nil" . :nil)
        ("or" . :or)
        ("print" . :print)
        ("return" . :return)
        ("super" . :super)
        ("this" . :this)
        ("true" . :true)
        ("var" . :var)
        ("while" . :while)))
  
    (defparameter +keywords+
      ;; A hash table created from keyword-alist.
      ;; Key being the lexeme and value being the token name.
      ;; Lexeme is a string and token name is a keyword symbol.
      (alexandria:alist-hash-table +keywords-alist+
                                   :test #'equal
                                   :size (length +keywords-alist+))))
  
  (deftype token-type ()
    `(member
      ;; Single-character tokens
      ,@(mapcar #'second +1char-token-associations+)
      ;; One or two character tokens
      ,@(mapcan (alexandria:curry #'mapcar #'second) +1-or-2-char-token-associations+)
      ;; Literals
      ,@+literals+
      ;; Keywords.
      ,@(mapcar #'cdr +keywords-alist+)
      ;; EOF token
      :eof))
  
  (defclass Token ()
  