[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

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

From: Pascal J. Bourguignon
Subject: Re: `list-of' macro snippet [regarding Comprehensions]
Date: Sat, 03 Nov 2012 04:09:30 +0100
User-agent: Gnus/5.13 (Gnus v5.13) Emacs/23.4 (darwin)

Rivka Miller <> writes:

> This is not that hard.
> You can take the defmacro  comp out of the defun.
> It should not be hard
> ----------------------------------------
> background info in
> 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?

__Pascal Bourguignon__

reply via email to

[Prev in Thread] Current Thread [Next in Thread]