Помогите кроваво пропатчить

(define-values (res body)
  (http-get site))

(define (read-header port)
  "Read one HTTP header from PORT. Return two values: the header
name and the parsed Scheme value. May raise an exception if the header
was known but the value was invalid.

Returns the end-of-file object for both values if the end of the message
body was reached (i.e., a blank line)."
  (let ((line (read-header-line port)))
    (if (or (string-null? line)
            (string=? line "\r"))
        (values *eof* *eof*)
        (let* ((delim (or (string-index line #\:)
                          (bad-header '%read line)))
               (sym (string->header (substring line 0 delim))))  ;;;; <--------- Символ cache-control из заголовка
          (values
           sym
           (parse-header
            sym
            (read-continuation-line
             port
             (string-trim-both line char-set:whitespace (1+ delim)))))))))  ;;;; <-------- ТУТ привязывается значение

(define-values (res body)
  (http-get "https://2ch.hk/pr/"))

< Cache-Control: no-cache
< Pragma: no-cache
< Cache-Control: max-age=0; must-revalidate; no-cache

(declare-key-value-list-header! "Cache-Control"
  (lambda (k v-str)
    (case k
      ((max-age min-fresh s-maxage)
       (parse-non-negative-integer v-str))
      ((max-stale)
       (and v-str (parse-non-negative-integer v-str)))
      ((private no-cache)
       (and v-str (split-header-names v-str)))
      (else v-str)))
  (lambda (k v)
    (case k
      ((max-age min-fresh s-maxage)
       (non-negative-integer? v))
      ((max-stale)
       (or (not v) (non-negative-integer? v)))
      ((private no-cache)
       (or (not v) (list-of-header-names? v)))
      ((no-store no-transform only-if-cache must-revalidate proxy-revalidate)
       (not v))
      (else
       (or (not v) (string? v)))))
  (lambda (k v port)
    (cond
     ((string? v) (default-val-writer k v port))
     ((pair? v)
      (put-char port #\")
      (write-header-list v port)
      (put-char port #\"))
     ((integer? v)
      (put-non-negative-integer port v))
     (else
      (bad-header-component 'cache-control v)))))

Cache-Control: no-cache,no-store,max-age=0,must-revalidate

(define* (parse-key-value-list str #:optional
                               (val-parser default-val-parser)
                               (start 0) (end (string-length str)))
  (let lp ((i start))
    (if (not (< i end))
        '()
        (let* ((i (skip-whitespace str i end))
               (eq (string-index str #\= i end))
               (comma (string-index str #\, i end))
               (delim (min (or eq end) (or comma end)))
               (k (string->symbol
                   (substring str i (trim-whitespace str i delim)))))
          (call-with-values
              (lambda ()
                (if (and eq (or (not comma) (< eq comma)))
                    (let ((i (skip-whitespace str (1+ eq) end)))
                      (if (and (< i end) (eqv? (string-ref str i) #\"))
                          (parse-qstring str i end #:incremental? #t)
                          (values (substring str i
                                             (trim-whitespace str i
                                                              (or comma end)))
                                  (or comma end))))
                    (values #f delim)))
            (lambda (v-str next-i)
              (let ((v (val-parser k v-str))
                    (i (skip-whitespace str next-i end)))
                (unless (or (= i end) (eqv? (string-ref str i) #\,))
                  (bad-header-component 'key-value-list
                                        (substring str start end)))
                (cons (if v (cons k v) k)
                      (lp (1+ i))))))))))

(define* (parse-key-value-list str #:optional
                               (val-parser default-val-parser)
                               (start 0) (end (string-length str)))
  (let lp ((i start))
    (if (not (< i end))
        '()
        (let* ((i (skip-whitespace str i end))
               (eq (string-index str #\= i end))
               (comma (min (string-index str #\, i end) (string-index str #\; i end)))
               (delim (min (or eq end) (or comma end)))
               (k (string->symbol
                   (substring str i (trim-whitespace str i delim)))))
          (call-with-values
              (lambda ()
                (if (and eq (or (not comma) (< eq comma)))
                    (let ((i (skip-whitespace str (1+ eq) end)))
                      (if (and (< i end) (eqv? (string-ref str i) #\"))
                          (parse-qstring str i end #:incremental? #t)
                          (values (substring str i
                                             (trim-whitespace str i
                                                              (or comma end)))
                                  (or comma end))))
                    (values #f delim)))
            (lambda (v-str next-i)
              (let ((v (val-parser k v-str))
                    (i (skip-whitespace str next-i end)))
                (unless (or (= i end) (eqv? (string-ref str i) #\,) (eqv? (string-ref str i) #\;))
                  (bad-header-component 'key-value-list
                                        (substring str start end)))
                (cons (if v (cons k v) k)
                      (lp (1+ i))))))))))

(module-define!
 (resolve-module '(web http))
 'parse-key-value-list
 (lambda* (parse-key-value-list str #:optional
                                (val-parser default-val-parser)
                                (start 0) (end (string-length str)))
   (let lp ((i start))
     (if (not (< i end))
         '()
         (let* ((i (skip-whitespace str i end))
                (eq (string-index str #\= i end))
                (comma (min (string-index str #\, i end) (string-index str #\; i end)))
                (delim (min (or eq end) (or comma end)))
                (k (string->symbol
                    (substring str i (trim-whitespace str i delim)))))
           (call-with-values
               (lambda ()
                 (if (and eq (or (not comma) (< eq comma)))
                     (let ((i (skip-whitespace str (1+ eq) end)))
                       (if (and (< i end) (eqv? (string-ref str i) #\"))
                           (parse-qstring str i end #:incremental? #t)
                           (values (substring str i
                                              (trim-whitespace str i
                                                               (or comma end)))
                                   (or comma end))))
                     (values #f delim)))
             (lambda (v-str next-i)
               (let ((v (val-parser k v-str))
                     (i (skip-whitespace str next-i end)))
                 (unless (or (= i end) (eqv? (string-ref str i) #\,) (eqv? (string-ref str i) #\;))
                   (bad-header-component 'key-value-list
                                         (substring str start end)))
                 (cons (if v (cons k v) k)
                       (lp (1+ i)))))))))))

$ HEAD ya.ru | grep Cache
Cache-Control: no-cache,no-store,max-age=0,must-revalidate

Cache-Control: max-age=0; must-revalidate; no-cache

(require 
  (prefix-in a: very-long-package-name) 
  (rename-in package-name 
    (long-name-to-list-directory ls)
    (long-name-to-count-words wc)))

CL-USER> (defpackage #:test1
           (:use #:cl)
           (:export #:var-test11
                    #:var-test12))
#<PACKAGE "TEST1">
CL-USER> (in-package #:test1)
#<PACKAGE "TEST1">
TEST1> (defvar var-test11 11)
VAR-TEST11
TEST1> (defvar var-test12 12)
VAR-TEST12
TEST1> (defpackage #:test2
         (:use #:cl)
         (:local-nicknames (#:t1 #:test1)))
#<PACKAGE "TEST2">
TEST1> (in-package #:test2)
#<PACKAGE "TEST2">
TEST2> (define-symbol-macro vt11 t1:var-test11)
VT11
TEST2> vt11
11
TEST2> t1:var-test12
12
TEST2> 

...
TEST2> (symbol-value 'vt11)
The variable VT11 is unbound.
   [Condition of type UNBOUND-VARIABLE]

(use-modules (web http))

(define skip-whitespace (@@ (web http) skip-whitespace))
(define trim-whitespace (@@ (web http) trim-whitespace))
(define parse-qstring (@@ (web http) parse-qstring))
(define bad-header-component (@@ (web http) bad-header-component))
(define (default-val-parser k val)
  val)

(module-define!
 (resolve-module '(web http))
 'parse-key-value-list
 (lambda* (str #:optional
               (val-parser default-val-parser)
               (start 0) (end (string-length str)))
   (let lp ((i start))
     (if (not (< i end))
         '()
         (let* ((i (skip-whitespace str i end))
                (eq (string-index str #\= i end))
                (comma (let ((q1 (string-index str #\, i end))
                             (q2 (string-index str #\; i end)))
                         (if (and q1 q2)
                             (min q1 q2)
                             (or q1 q2))))
                (delim (min (or eq end) (or comma end)))
                (k (string->symbol
                    (substring str i (trim-whitespace str i delim)))))
           (call-with-values
               (lambda ()
                 (if (and eq (or (not comma) (< eq comma)))
                     (let ((i (skip-whitespace str (1+ eq) end)))
                       (if (and (< i end) (eqv? (string-ref str i) #\"))
                           (parse-qstring str i end #:incremental? #t)
                           (values (substring str i
                                              (trim-whitespace str i
                                                               (or comma end)))
                                   (or comma end))))
                     (values #f delim)))
             (lambda (v-str next-i)
               (let ((v (val-parser k v-str))
                     (i (skip-whitespace str next-i end)))
                 (unless (or (= i end)
                             (eqv? (string-ref str i) #\,)
                             (eqv? (string-ref str i) #\;))
                   (bad-header-component 'key-value-list
                                         (substring str start end)))
                 (cons (if v (cons k v) k)
                       (lp (1+ i)))))))))))