News for hackers. Stuff that matters.
Re:Why Lisp macros are cool, a Perl perspective (2005) by Scriptor on Monday August 31, 2009 @12:47AM (#795453)
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)
Re:Why Lisp macros are cool, a Perl perspective (2005) by abecedarius on Monday August 31, 2009 @12:57AM (#795461)
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.

Re:Why Lisp macros are cool, a Perl perspective (2005) by masklinn on Monday August 31, 2009 @04:56AM (#795623)
> 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.

Re:Why Lisp macros are cool, a Perl perspective (2005) by scott_s on Monday August 31, 2009 @09:53AM (#795895)
Ah, thanks for that. In Perl and shell scripts, it's the equivalent of $ - that is, "my name is $name".
Re:Why Lisp macros are cool, a Perl perspective (2005) by aufreak on Monday August 31, 2009 @03:02AM (#795547)

  (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)))
Re:Why Lisp macros are cool, a Perl perspective (2005) by smanek on Monday August 31, 2009 @12:58AM (#795465)
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...

Re:Why Lisp macros are cool, a Perl perspective (2005) by tumult on Monday August 31, 2009 @02:12AM (#795512)
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.
Re:Why Lisp macros are cool, a Perl perspective (2005) by diiq on Monday August 31, 2009 @10:40AM (#795988)
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).
Re:Why Lisp macros are cool, a Perl perspective (2005) by lhorie on Monday August 31, 2009 @09:48AM (#795888)
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.