Hi, can Lisp macros call themselves recursively?
I tried something like `(foo ,(blarb ...)) inside a blarb macro, and get
some kind of error (telling me that blarb isn't a function).
I rewrote the macro to simply call a recursive function that does the
macro-expansion, and it works, but it doesn't seem too elegant...
--
the bottom line is that a JavaSchool that won't teach C and won't teach
Scheme is not really teaching computer science, either. -- Joel Spolsky
In article <···············@individual.net>,
Ulrich Hobelmann <···········@web.de> wrote:
> Hi, can Lisp macros call themselves recursively?
>
> I tried something like `(foo ,(blarb ...)) inside a blarb macro, and get
> some kind of error (telling me that blarb isn't a function).
>
> I rewrote the macro to simply call a recursive function that does the
> macro-expansion, and it works, but it doesn't seem too elegant...
It should probably be something like `(foo (blarb ,...)). The macro
should expand into code that makes another call to the macro.
However, remember that the macro is being expanded at compile time, so
the termination condition of the recursion has to be something that can
be determined from the lexical sub-expressions that it operates on. It
can't recurse on run-time variable values.
--
Barry Margolin, ······@alum.mit.edu
Arlington, MA
*** PLEASE post questions in newsgroups, not directly to me ***
*** PLEASE don't copy me on replies, I'll read them in the group ***
Barry Margolin wrote:
> In article <···············@individual.net>,
> Ulrich Hobelmann <···········@web.de> wrote:
>
>> Hi, can Lisp macros call themselves recursively?
>>
>> I tried something like `(foo ,(blarb ...)) inside a blarb macro, and get
>> some kind of error (telling me that blarb isn't a function).
>>
>> I rewrote the macro to simply call a recursive function that does the
>> macro-expansion, and it works, but it doesn't seem too elegant...
>
> It should probably be something like `(foo (blarb ,...)). The macro
> should expand into code that makes another call to the macro.
Yes, thanks to you and Bruce. That works. Completely forgot that
macro-expansions will automatically expand again...
> However, remember that the macro is being expanded at compile time, so
> the termination condition of the recursion has to be something that can
> be determined from the lexical sub-expressions that it operates on. It
> can't recurse on run-time variable values.
Oh sure, otherwise even the function invoked by the macro wouldn't
terminate.
--
the bottom line is that a JavaSchool that won't teach C and won't teach
Scheme is not really teaching computer science, either. -- Joel Spolsky
"Ulrich Hobelmann" <···········@web.de> wrote in message
····················@individual.net...
> Barry Margolin wrote:
>> In article <···············@individual.net>,
>
>> However, remember that the macro is being expanded at compile time, so
>> the termination condition of the recursion has to be something that can
>> be determined from the lexical sub-expressions that it operates on. It
>> can't recurse on run-time variable values.
>
> Oh sure, otherwise even the function invoked by the macro wouldn't
> terminate.
If by "the function invoked by the macro" you mean the macro function, then
you've got it. If you mean the functions called in the macro-expansion then
no, they will never run you will overflow the stack at macro-expansion time,
usually compile time.
--
Coby Beck
(remove #\Space "coby 101 @ bigpond . com")
Coby Beck wrote:
> "Ulrich Hobelmann" <···········@web.de> wrote in message
> ····················@individual.net...
>> Barry Margolin wrote:
>>> In article <···············@individual.net>,
>>> However, remember that the macro is being expanded at compile time, so
>>> the termination condition of the recursion has to be something that can
>>> be determined from the lexical sub-expressions that it operates on. It
>>> can't recurse on run-time variable values.
>> Oh sure, otherwise even the function invoked by the macro wouldn't
>> terminate.
>
> If by "the function invoked by the macro" you mean the macro function, then
> you've got it. If you mean the functions called in the macro-expansion then
> no, they will never run you will overflow the stack at macro-expansion time,
> usually compile time.
No, my defmacro was just a wrapper, calling the recursive function that
built the expanded Lisp code. Now it's all just one macro, but it does
the same stuff, i.e. only recur on the input given an compile-time.
--
the bottom line is that a JavaSchool that won't teach C and won't teach
Scheme is not really teaching computer science, either. -- Joel Spolsky
In article <···············@individual.net>,
Ulrich Hobelmann <···········@web.de> wrote:
> Hi, can Lisp macros call themselves recursively?
>
> I tried something like `(foo ,(blarb ...)) inside a blarb macro, and get
> some kind of error (telling me that blarb isn't a function).
The problem is the comma. Lose it. Then '(foo (blarb ...)) will be
returned as the result of your macro, and CL will parse it and go "oh ..
there's a blarb macro in here .. better expand it".
--
Bruce | 41.1670S | \ spoken | -+-
Hoult | 174.8263E | /\ here. | ----------O----------