Stefan Ram wrote:
> ········@gmail.com" <·······@gmail.com> writes:
>
>>>For example, in Lisp, one can write macros for reoccuring
>>>idioms, but anyone who wants to read a program using them has
>>>to learn these macros first (or at least, when he is reading a
>>>usage of one of these macros).
>>
>>The answer to this old argument is that this is no different from
>>procedures.
>
>
> In most programming languages, parameters of procedures are
> strict (they are evaluated at the time of the call). This
> gives the reader of an invocation of a procedure some basic
> information that is always valid. (In languages with
> call-by-value only, one even can deduce that a call will never
> alter an argument variable.)
>
> Macros might have lazy parameters (they do not need to
> evaluate all of their arguments), which opens more
> possibilities for the interpretation of a macro call than for
> the interpretation of a procedure name - even in the presence
> of a good mnemonic macro name. They also might modify an
> argument variable or do other things procedures can't do
> and are overall more powerful than procedure calls.
We might have a forest for the trees situation here, trying to make
sense out of the value of macros by this bizarre metric of how much gets
done with arguments. That is what happens when smart people get to
bullshitting. A simpler approach to the question can be had from simple
application programmers like me, who would point out that we use macros
to hide repetitive boilerplate. Wow. That means the essence of what is
going on at any point in the code is not hard to find, everything that
is not essence is handled by the macro-expansion. The moral of the story
is that the last thing we want to know is what is being done with the
arguments, we just want the name of the macro to be honored by its
performance.
When things go wrong... can you say macroexpand? Sher ya can.
kt
--
http://smuglispweeny.blogspot.com/
http://www.theoryyalgebra.com/
"I've never read the rulebook. My job is to catch the ball."
-- Catcher Josh Bard after making a great catch on a foul ball
and then sliding into the dugout, which by the rules allowed the
runners to advance one base costing his pitcher a possible shutout
because there was a runner on third base.
"My sig is longer than most of my articles."
-- Kenny Tilton