On Tue, Mar 18, 2014 at 8:54 PM, Paul Tarvydas paultarvydas@gmail.comwrote:

@All, thanks for the interesting discussion. Certainly gives me something to chew on.

Re-reading the responses, I see that, while I did sort-of say it, I didn't emphasize the point of this:

I have a PEG-syntax parser written in esrap.

I am binding at least two such parsers as reader-macros (not the normal kind of macro).

I always thought that reader macros should be called a different name, because they are not macros. Yes, they produce code; but that's the only point they have in common with macros. The two should not be confused.

The first parser parses PEG syntax and creates an esrap program.

That esrap program, bound as a reader-macro, reads Prolog syntax and returns a bunch of lisp forms to the reader.

I have a file of code that contains both, lisp and Prolog syntax (cl-heredoc to switch between the syntaxes), e.g.

https://github.com/guitarvydas/paraphrase/blob/master/prolog.lisp

The parsers read characters, not forms.

(lisp) #{ prolog(A,B,c) :- p1(A), p2(B,c). } (morelisp)

I am making at least 2 assumptions:

1. That using different name spaces for the various parsers will help me

preserve my sanity, (regression testing the PEG parser using itself brings me to the limits of my comprehension :-),

2. That a reader macro must return a single form. I actually want to

return a separate 'defun' for every prolog rule in the file. (Writing this, just now, makes me ask myself why I don't just put #{ ... } around every separate rule...)

(I even started fooling around with a Python syntax).

This line of thinking was inspired by the Gambit Scheme talk at ILC2010, where they showed inline infix mathematical expressions.

Thanks for your suggestions.

Your assumptions are sane. You only have to understand in which phase - read-time, compile-time, run-time - each piece of your code happens to run. Your reader macros generate Lisp code (defun forms), right? Where do the symbols that constitute those forms come from? Let me guess... I bet some come from the source code of the reader macro itself - e.g., the symbol CL:DEFUN. I bet others come from calls you make to the function intern or find-symbol. Am I right? If so, ask yourself: which package is effective at the time you call intern/find-symbol? Can you change it to another one? What happens if you do so?