Re: `list-of' macro snippet [regarding Comprehensions]

[Rivka Miller]

On Nov 2, 8:09 pm, "Pascal J. Bourguignon" <address@hidden>
wrote:
> Rivka Miller <address@hidden> writes:
> > This is not that hard.
>
> > You can take the defmacro  comp out of the defun.
>
> > It should not be hard
> > ----------------------------------------
> > background info in gnu.emacs.help
>
> > I spent a few hours poring over and fixed some of the variables and
> > backquotes and character codes.
>
> > The defmacro is now only nested in one function where it is needed.
> > Hope, someone can help get it to work and produce some kind of demo
> > examples.
>
> > (defun open-bracket (stream ch)
>
> >   (defmacro comp ((e &rest qs) l2)
> >     (if (null qs) `(cons ,e ,l2)        ; rule A
> >       (let ((q1 (car qs))
> >             (q (cdr qs)))
> >         (if (not(eq (cadr q1) '<-))  ; a generator?
> >             `(if ,q1 (comp (,e ,@q),l2) ,l2) ; rule B
> >           (let ((v (car q1))            ; rule C
> >                 (l1 (third q1))
> >                 (h (gentemp "H-"))
> >                 (us (gentemp "US-"))
> >                 (us1 (gentemp "US1-")))
> >             `(labels ((,h (,us)         ; corresponds to a letrec
> >                           (if (null ,us) ,l2
> >                             (let ((,v (car ,us))
> >                                   (,us1 (cdr ,us)))
> >                               (comp (,e ,@q) (,h ,us1))))))
> >                (,h ,l1)))))))
>
> >   (do ((l nil)
> >        (c (read stream t nil t)(read stream t nil t)))
> >       ((eq c '|]|) `(comp ,(reverse l) ()))
> >   (push c l))
> > )
>
> > (defun closing-bracket (stream ch) '|]|)
>
> > (eval-when (compile load eval)
> >   (set-macro-character #\[ #'open-bracket)
> >   (set-macro-character #\] #'closing-bracket))
>
> Why are you repeating this code here in comp.lang.lisp?
>
> I already told you that it was nonsensical!
>
> When you put the defmacro for inside the defun, it may not have
> compile-time effects.  Therefore when you compile a file containing
> brackets, the reader macro function will be called, the macro will be
> defined, but maybe only into the run-time environment, not into the
> compilation environment.  Therefore the compiler may not know that COMP
> is a macro, and it may very well signal an error when compiling a
> bracket expression!
>
> Why do you insist putting the defmacro inside the defun?

You must have read in a hurry. In previous post, I actually said

>> You can take the defmacro  comp out of the defun.

Now, you can take it out and try to run it in emacs and put some run
examples.

R