Common Lisp. Почему переменные «позволяют» сохранять изменения, внесенные в них в новых итерациях?

Я начинающий лингвист и решил написать бота для Telegram в качестве тестового проекта. Здесь я столкнулся с неожиданным поведением let. Код представлен в виде системы .asd с одним файлом, содержащим следующий код. Важная часть, на которую следует обратить внимание:

1. long-poll-updates функция по сути представляет собой цикл.

2. Вызов read-updates в long-poll-updates функции

3. Вызов check-integrity в функции read-updates.

4. checks переменная в произвольной форме.

На каждой итерации основного цикла я делаю (prin1 checks) и вижу что-то, что мне трудно найти или понять. На первой итерации цикла он печатает именно то значение, которое я ему присвоил. Каждая новая итерация не переназначает значения nil обратно, а использует те же точные значения, которые остались после операций предыдущей итерации.

(defun long-poll-updates ()
    "Main loop. Repeatedly sends requests to get updates."
    ; Sets a variable for storing the last processed updates's ID.
    (let ((offset 0)) (loop
        (let* ((api-answer  (get-updates-request offset))
               (parsed-plist (jonathan:parse 
                             (flexi-streams:octets-to-string api-answer))))

            ;; Read response and modify offset parameter to get next updates.
            (let ((response-data (read-updates parsed-plist)))  
                (when (getf response-data :has-results) 
                    (setf offset 
                        (1+ (getf response-data :last-update-id)))))))))

(defun read-updates (response-plist)
    "Reads the incoming long poll response: 
     checks for response validity/errors, 
     proceeds to an appropriate action."
    (let ((response-data (check-integrity response-plist)))
            (cond ((getf response-data :has-ok)
                (cond ((getf response-data :is-ok)
        ;; Evaluate updates on successful poll
                    (cond
                        ((getf response-data :has-results)
                            (setf (getf response-data :last-update-id) 
                            (eval-updates response-plist)))
                    (t
                        (log-data "No results received."))))
                (t (log-errors response-plist))))
            (t (log-data "Received malformed JSON-response while long polling."))) 
        response-data))

(defun check-integrity (response-plist)
    "Runs checks for valid JSON received, success/faliure and presence of new updates.
     Returns a plist of checks passed/failed."
    (let ((checks '(:has-ok nil 
                    :is-ok nil 
                    :has-results nil)))
        (prin1 checks)

        (loop :for  (indicator value) on response-plist by #'cddr
              ;; If successful response:
              :when (eql indicator :|ok|)
              :do   (progn 
                        (setf (getf checks :has-ok) t)
                        (when (eql value t)
                            (setf (getf checks :is-ok) t)))
              ;; If any results:
              :when (and (eql indicator :|result|)
                     (listp value)
                     (< 0 (length value)))
              :do   (setf (getf checks :has-results) t))
        checks))

Полагаю, я ожидал, что код функции будет оцениваться заново каждый раз, когда она вызывается, даже не осознавая этого. Тем не менее, похоже, что компилятор оценивает данные какому-то объекту, который никогда не покидает память, прежде чем код когда-либо будет запущен. Может ли кто-нибудь указать мне на более великую идею, с которой я здесь имею дело?

Я вижу, что подход lisp на самом деле «сначала теория», и я редко встречаю людей, которые действительно документируют проблемы, с которыми они сталкиваются, подходя к нему в блочной и буквальной манере (или как бы это ни выглядело, когда вы новичок в lisp, но уже имеете опыт программирования). . Мне это кажется невероятно странным, но дело не в этом.