Re: Is it possible for a macro to expand to nothing?

[Alan Mackenzie <acm@muc.de>]

Pascal J. Bourguignon <pjb@informatimago.com> wrote:
> Alan Mackenzie <acm@muc.de> writes:

>> Kevin Rodgers <kevin.d.rodgers@gmail.com> wrote:
>>> Alan Mackenzie wrote:

>>>> Your notion of the correct use of macros seems to be a religious idea
>>>> rather than one fully thought through.  You justify it with circular
>>>> reasoning.  Whilst using a macro to generate an evalable form may be
>>>> the most usual thing, there is no reason not to use it to produce
>>>> other list structure.

>>> Except that such macros can only be executed in a particular context
>>> i.e.  they depend on something that cannot be expressed via their
>>> argument list.

>> Yes, many lisp structures can only be "executed" in particular contexts,
>> `,@' for example, yet nobody slags them off for that.

> This is different.  Why can't you see it?

I do see it.  I'm glad we both do - there are things which _are_
different.

> ,@ cannot be put outside of a ` context, never ever.

Yes.  It is a thing which can only be "executed" in a particular context.
We live with this.

> When you define a macro (defmacro m ...) then (m ...) can be put in any
> form context, always.

No.  When _you_ define a macro that might well be the case, but with me
there are no guarantees.  I might want a macro to generate an arm of a
cond form, for example.  Unlikely, but possible.

> Oops! Not when you write a macro that returns not a form.  You've made
> an exception, and therefore a lot of complexity for the reader of your
> code, and a lot of time lost for the debugger of your code.

Right.  We now get down to weighing up the difficulties a non-form macro
may cause to its readers compared with the simplicity in the manner of
expression which it would allow.

> Now instead of being able to use a macro at any place a form is
> acceptable, we have to go read the source of the macro, and understand
> whether it returns a form or data, and if it's the later, we have to
> understand how to wrap it in some boilerplate, which was by the way
> why macros where invented for in the first place, to avoid
> boilerplate!!!  How silly!

No, not silly - it all depends.  In the example which sparked off this
intelligent discussion, avoiding non-conformity required inserting an
artificial `progn'.  It's a matter of judgement which is the more
difficult to read and understand.



>>> At best that is poor style, and at worst it is poor engineering.

>> That is so supercilious - you haven't even given an example of this
>> phenomenom, discussing why it is poor style or poor engineering.  There's
>> just this vague insinuation that you know better.

> Yes, it seems that we have to spell it in all details.

Yes, indeed.  Or at least, in some considerable detail.

>> I will give an example, namely `c-lang-defconst' from cc-defs.el.  Are
>> you going to assert that it is poor style, or even poor engineering,
>> simply because it generates an internal data structure rather than an
>> excutable form?  

> You are plain wrong.  c-lang-defconst, as any other macro, generates
> only executable lisp code:

Yes, I was wrong.  Sorry about that.  I'm beginning to see what you're
getting at.

> (c-lang-defconst test t nil c "abc")
> --> test

> (macroexpand '(c-lang-defconst test t nil c "abc"))
> --> (progn (c-define-lang-constant (quote test) (quote (((c-mode) . "abc") (t))) (quote (\83))))

I still don't see the _reason_ for macros always to return forms.  I
think you're saying that anything else is so unusual that it would create
problems for somebody reading or debugging it.  Do you have an example of
somewhere where a macro expanding to a non-form has lead to difficulty?
I can't imagine anybody having difficulty understanding code like this:

(cond
 (try-incoming-call event)  ; expands to a full cond arm
 (try-incoming-data-call event)
 (try-battery-low-notification event)
 (try-keyboard-press event)
 ....
 )

, where all these event handler macros are defined centrally just once
(and the comment is actually present in the source).

I'll quite happily use a goto in C code if it makes the code easier to
read and understand, though I've only done this 3 or 4 times in my entire
career.  Similarly, I'd use a non-form macro if this were better.
Usually it wouldn't be.

-- 
Alan Mackenzie (Nuremberg, Germany).