anchor.diff:  ;; Defining Token
   ;; ;;;;;;;;;;;;;;
   
  -(defparameter +1char-token-associations+
  -  '((#\( :left-paren)
  -    (#\) :right-paren)
  -    (#\{ :left-brace)
  -    (#\} :right-brace)
  -    (#\, :comma)
  -    (#\. :dot)
  -    (#\- :minus)
  -    (#\+ :plus)
  -    (#\* :star)
  -    (#\/ :slash)
  -    (#\; :semicolon)))
  -
  -(defparameter +keywords+
  -  #.(let ((keywords-alist
  -            '(("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))))
  -      (alexandria:alist-hash-table keywords-alist
  -                                   :test #'equal
  -                                   :size (length keywords-alist))))
  +(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
  -    :left-paren :right-paren
  -    :left-brace :right-brace
  -    :comma :dot :minus :plus :star :slash :semicolon
  -
  +    ,@(mapcar #'second +1char-token-associations+)
       ;; One or two character tokens
  -                :bang :bang-equal
  -                :equal :equal-equal
  -                :greater :greater-equal
  -                :less :less-equal
  -
  -                ;; Literals
  -                :identifier :string :number
  -
  -                ;; Keywords.
  -    :and :class :else :false :fun :for :if :nil :or
  -                :print :return :super :this :true :var :while
  -
  +    ,@(mapcan (alexandria:curry #'mapcar #'second) +1-or-2-char-token-associations+)
  +    ;; Literals
  +    ,@+literals+
  +    ;; Keywords.
  +    ,@(mapcar #'cdr +keywords-alist+)
  +    ;; EOF token
       :eof))
   
   (defclass Token ()
  
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:   (or (is-alpha char)
        (is-digit char)))
  
  ;; 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."
    (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)
    "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))))
  