Why Lisp macros are cool, a Perl perspective (2005)(lists.warhead.org.uk)

103 pointsby edvor 17 Jahren18 comments

lists.warhead.org.uk

Why Lisp macros are cool, a Perl perspective (2005)

http://lists.warhead.org.uk/pipermail/iwe/2005-July/000130.html

21 comments

dstein64vor 17 Jahren

Is there any significance to the "=3D" in his code, or are those the same as the normal equal "="? Thanks.

Even for those who don't need to be sold on Lisp macros, that was worth reading just for this sentence (in reference to C++ macros):

I forgot what rabid programming language fans are like; they can and will defend any system, no matter how dysfunctional, as long as it's _their_ dysfunctional sytem.

:-)

Scriptorvor 17 Jahren

Question about the code:

  (defmacro set-sqrt (place v) `(setf ,place (* v v)))

What does the comma right before place in its second usage signify?

Also, am I right in assuming that setf turns:

  (setf (f1 arg1) arg2)

into

  (setter-for-f1 arg1 arg2)

abecedariusvor 17 Jahren

The comma means to use the value of place there, instead of the literal symbol 'place'.

(Ironically, MJD made one of the same mistakes there he complained about in his C examples -- mentioning 'v' twice, which makes any side effects happen twice. Lisp macros are better than C's, but still require some care.)

defsetf turns that expression into whatever the defsetf expander for f1 returns -- it's up to the code.

masklinnvor 17 Jahren

> What does the comma right before place in its second usage signify?

It "punches a hole" in the quote: the ` in `(setf ,place (* v v)) says "don't evaluate this, this is a litteral value/list", but then the comma indicates "actually evaluate just this expression right here within the definition context" so ,place will be replaced by the value of the place argument. It's kinda equivalent to #{} in Ruby strings.

As others have pointed out, v should probably be unquoted as well.

scott_svor 17 Jahren

Ah, thanks for that. In Perl and shell scripts, it's the equivalent of $ - that is, "my name is $name".

aufreakvor 17 Jahren

  (defmacro set-sqrt (place v) `(setf ,place (* v v)))

should actually be

  (defun square (x) (* x x))
  (defmacro set-sqrt (place v) `(setf ,place (square ,v)))

[deleted]vor 17 Jahren

smanekvor 17 Jahren

The comma 'unquotes' the place variable so it is replaced with the value passed to the first argument on set-sqrt. I'm not in front of a lisp interpreter, but I think both those v's should be unquoted too in order to get the expected behavior ... (plus they are a bit leaky since they are evaluated twice, but that's just being pedantic).

Read http://www.gigamonkeys.com/book/macros-defining-your-own.htm... for a more thorough explanation.

As for setf, a user can create arbitrary 'setters' using syntax like that described at http://gigamonkeys.com/book/object-reorientation-classes.htm...

tumultvor 17 Jahren

I'm not a CL guy so I don't know how defsetf actually works, but I skipped down in that link to where that Lisp macro is, and if defsetf works like he describes (and I don't know if it does), then

    (setf (f1 arg1) arg2)

will cause an error, but

    (setf (sqrt arg1) arg2)

will expand into

    (setf arg1 (* v v))

which, as you can see, is nonsensical in terms of what it looks like he was trying to do.

diiqvor 17 Jahren

Yes, as has been pointed out, he is missing a pair of commas (or more correctly, a patch to ensure that v is evaluated once and only once --- right now it is evaluated 0 times, and adding 2 commas would make it eval twice. Using the definition of (square x) is the cleanest way to fix this).

anonjonvor 17 Jahren

lhorievor 17 Jahren

The way I memorized it was to associate it with #{...} in ruby:

  def my_gimme(thing)
    gimme "select #{thing} from something"
  end

Of course, in lisp, the "interpolation" (and macros in general) is structural: you can't use malformed strings to inject unexpected code like you could in my silly example.

Incidentally, Stuart Halloway uses this same Ruby syntax as pseudo-code when he first introduces macro syntax in his Programming Clojure book.

aufreakvor 17 Jahren

Here is a link to the section on "what makes lisp different" that is referred to in the article -

http://bit.ly/8yrvC

benatkinvor 17 Jahren

For a long while I've thought that Randall Schwartz was the author of Higher Order Perl. Oops.

SwellJoevor 17 Jahren

Higher Order Perl is a fantastic book, which makes a lot of functional concepts more immediately usable for non-Lisp dynamic language programmers (the example language is Perl, but there are projects on the web to convert the examples to other languages; the concepts apply across most of the popular dynamic languages).

[deleted]vor 17 Jahren

bkovitzvor 17 Jahren

And yet, still no example of a useful macro.

In C++, you already have assignment. You don't need to roll your own.

telvor 17 Jahren

Try this: http://www.paulgraham.com/onlisp.html

masklinnvor 17 Jahren

> And yet, still no example of a useful macro.

http://en.wikipedia.org/wiki/CLOS

_cbszvor 17 Jahren

As a non-Lisper:

In short, macros are cool because, instead of hacking the compiler and groveling through its weird data structures to add language features, you can add language features in the language itself, because the language is already traditionally expressed in parse trees. Phrased this way, I don't see why this is a life-changing revelation.