compiler-output.txt

1 compiler notes:

test-who-with-iterate.lisp:13:6:
  warning: 
    Iterate, in clause (LET ((S S))
                         (CHECK-TYPE S STREAM)
                         (MACROLET ((HTM (&BODY BODY)
                                      `(WITH-HTML-OUTPUT (,'S NIL PROLOGUE NIL
                                                          INDENT ,NIL)
                                         ,@BODY))
                                    (FMT (&REST ARGS)
                                      `(FORMAT ,'S ,@ARGS))
                                    (ESC (THING)
                                      (WITH-UNIQUE-NAMES (RESULT)
                                        `(LET ((,RESULT ,THING))
                                           (WHEN ,RESULT
                                             (WRITE-STRING (ESCAPE-STRING ,RESULT)
                                                           ,'S)))))
                                    (STR (THING)
                                      (WITH-UNIQUE-NAMES (RESULT)
                                        `(LET ((,RESULT ,THING))
                                           (WHEN ,RESULT (PRINC ,RESULT ,'S))))))
                           (WRITE-STRING <li> S)
                           (LET ((*INDENT* NIL))
                             NIL
                             (STR (FORMAT NIL Item ~a I)))
                           (WRITE-STRING </li> S))):
    Iterate does not know how to handle the special form (MACROLET ((HTM
                                                                        (
                                                                         &BODY
                                                                         CL-WHO::BODY)
                                                                      `(WITH-HTML-OUTPUT (,'S
                                                                                          NIL
                                                                                          :PROLOGUE
                                                                                          NIL
                                                                                          :INDENT
                                                                                          ,NIL)
                                                                         ,@CL-WHO::BODY))
                                                                    (FMT
                                                                        (
                                                                         &REST
                                                                         CL-WHO::ARGS)
                                                                      `(FORMAT ,'S
                                                                               ,@CL-WHO::ARGS))
                                                                    (ESC
                                                                        (
                                                                         CL-WHO::THING)
                                                                      (CL-WHO::WITH-UNIQUE-NAMES (CL-WHO::RESULT)
                                                                        `(LET ((,CL-WHO::RESULT
                                                                                ,CL-WHO::THING))
                                                                           (WHEN
                                                                               ,CL-WHO::RESULT
                                                                             (WRITE-STRING
                                                                              (ESCAPE-STRING
                                                                               ,CL-WHO::RESULT)
                                                                              ,'S)))))
                                                                    (STR
                                                                        (
                                                                         CL-WHO::THING)
                                                                      (CL-WHO::WITH-UNIQUE-NAMES (CL-WHO::RESULT)
                                                                        `(LET ((,CL-WHO::RESULT
                                                                                ,CL-WHO::THING))
                                                                           (WHEN
                                                                               ,CL-WHO::RESULT
                                                                             (PRINC
                                                                              ,CL-WHO::RESULT
                                                                              ,'S))))))
                                                           (WRITE-STRING "<li>" S)
                                                           (LET ((CL-WHO::*INDENT*
                                                                  NIL))
                                                             NIL
                                                             (STR
                                                              (FORMAT NIL "Item ~a"
                                                                      I)))
                                                           (WRITE-STRING "</li>" S))
    It will not be walked, which means that Iterate clauses inside it will not be seen.
    ==>
      (ITERATE:ITER
        (ITERATE:FOR PLAYGROUND::I PLAYGROUND::FROM 1 PLAYGROUND::TO 10)
        (CL-WHO:HTM (:LI (CL-WHO:STR (FORMAT NIL "Item ~a" PLAYGROUND::I)))))
    

Compilation failed.

test-who-with-iterate.lisp

(ql:quickload '(iterate
                cl-who))

(defpackage playground
  (:use :cl
        :cl-who
        :iterate))
(in-package :playground)


(defun test-htm-with-iterate ()
  (with-html-output-to-string (s)
    (:ul
     (iterate (for i from 1 to 10)
              (htm (:li (str (format nil "Item ~a" i))))))))