`list-of' macro snippet [regarding Comprehensions]

[Rivka Miller]

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))

[Pascal J. Bourguignon]

Post by Rivka Miller
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?
(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)))
(,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?

[Rivka Miller]

Post by Pascal J. Bourguignon

Post by Rivka Miller
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?
          (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)))
               (,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

Post by Pascal J. Bourguignon

Post by Rivka Miller
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

[Rivka Miller]

Post by Rivka Miller

Post by Pascal J. Bourguignon

Post by Rivka Miller
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?
          (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)))
               (,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

Post by Pascal J. Bourguignon

Post by Rivka Miller
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

I still need someone to help me get the common-lisp comprehension code
working on emacs.

[Pascal J. Bourguignon]

Post by Rivka Miller
I still need someone to help me get the common-lisp comprehension code
working on emacs.

Require cl and use defmacro* instead of defmacro:


(require 'cl)
(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)))))))

(macroexpand '(comp (e (< 1 2)) l2))
--> (if (< 1 2) (comp (e) l2) l2)
(macroexpand '(comp (e) l2))
--> (cons e l2)