[common lisp][macro characters]Как читает лисп следующее выражение?

(read-delimited-list #\])
1 2 3]] ]
=> (1 2 3]])

(read-delimited-list #\])
1 2 3 ]
=> (1 2 3)

;;; The EACH macro.
;;;
(defmacro each ((element list) &body body)
  `(mapcar #'(lambda (,element)
               ,@body)
           ,list))

;;; The MANY macro.
;;;
(defmacro many (thing &rest forms)
  `(values
    ,@(each (form forms)
        (if (atom form)
            (if (atom thing)
                `(,thing ,form)
                `(,@thing ,form))
            (if (atom thing)
                `(,thing ,@form)
                `(,@thing ,@form))))))

;;; What is MANY:
;;;
;;;  (macroexpand-1 '(many (something a) b c d))
;;;  => (VALUES (SOMETHING A B) (SOMETHING A C) (SOMETHING A D))
;;;
;;;  (macroexpand-1 '(many defvar (a 1) (b 2) (c 3)))
;;;  => (VALUES (DEFVAR A 1) (DEFVAR B 2) (DEFVAR C 3))
;;;

(defun something (&rest args)
  (reduce #'+ args))

(defun gen-something-body (numbers)
  `(many (something ,(first numbers))
     ,@(rest numbers)))

(defmacro something-body (&rest numbers)
  (gen-something-body numbers))

;;;
;;; (macroexpand-1 (gen-something-body '(1 2 3)))
;;; => (VALUES (SOMETHING 1 2) (SOMETHING 1 3))
;;;
;;; (macroexpand-1 '(something-body 1 2 3))
;;; => (MANY (SOMETHING 1) 2 3)
;;;
;;; (macroexpand '(something-body 1 2 3))
;;; => (VALUES (SOMETHING 1 2) (SOMETHING 1 3))
;;;
;;; (something-body 1 2 3)
;;; =>
;;; (1 2)
;;; (1 3)
;;;

(defun read-square-list (&optional (input-stream *standard-input*))
  (let ((first-char (read-char input-stream))
        result-list)
    (assert (char= first-char #\[))
    (loop
      (let ((token (read input-stream)))
        (when (eq token '|]|)
          (return-from read-square-list (nreverse result-list)))
        (if (symbolp token)
            (let ((string (string token)))
              (when (and (not (string= string ""))
                         (char= (char string (1- (length string))) #\]))
                (return-from read-square-list
                  (append
                   (nreverse result-list)
                   (list (read-from-string (subseq string 0 (1- (length string)))))))))
            (push token result-list))))))

(defun read-square-list-from-string (string)
  (with-input-from-string (stream string)
    (read-square-list stream)))

;;;
;;; (read-square-list-from-string "[1 (2) #(3)]")
;;; => (1 (2) #(3))
;;;

(set-macro-character
 #\[
 #'(lambda (stream char)
     (declare (ignore char))
     (gen-something-body (read-square-list stream))))

;;;
;;; [1 2 3 4 5]
;;; =>
;;; 3
;;; 4
;;; 5
;;; 6
;;;

 (defun read-square-list (&optional (input-stream *standard-input*))
-  (let ((first-char (read-char input-stream))
-        result-list)
-    (assert (char= first-char #\[))
+  (let (result-list)
     (loop
       (let ((token (read input-stream)))

(set-macro-character #\] (get-macro-character #\)))
(set-macro-character
 #\[
 #'(lambda (stream char)
     (declare (ignore char))
     (gen-something-body (read-delimited-list #\] stream))))

;;;
;;; [1 2 3 4 5]
;;; =>
;;; 3
;;; 4
;;; 5
;;; 6
;;;