What is the best route for an experienced imperative style programmer only familiar with C macros to learn the Racket macro system. Not just the mechanics of it (the how?) but also the where and why to use it and examples that illustrate this.
Should one learn Scheme (or Lisp) macros first? I've heard that the book "On Lisp" has a good explanation of Lisp macros with excellent examples of their use. Would this be useful or not?
I believe that the best tutorial on macros is still Kent Dybvig's "Writing Hygenic macros in Scheme with syntax-case". It's not specifically about Racket, but basically everything will carry over, and reading the guide that Chris mentioned above will cover any remaining differences. Despite the name, it covers both "hygenic" and "unhygenic" macros.
Edit July 2014:
Since I wrote the above, Greg Hendershott has written a fabulous tutorial on macros in Racket, entitled Fear of Macros. That's now the best place to start learning about Racket macros.
Racket's documentation has an excellent tutorial on using macros.
I would definitely recommend Scheme macros over CL macros if you haven't deal with any sort of Lisp macros before. That's because Scheme macros use pattern matching, and it's much easier to read.
Example (using Racket's define-syntax-rule):
(define-syntax-rule (let ((var val) ...)
expr ...)
((lambda (var ...)
expr ...)
val ...))
This is a very simple macro that defines let in terms of creating a corresponding lambda, then applying it. It's easy to read, and easy to reason about what it does.
Slightly more complicated macro:
(define-syntax let*
(syntax-rules ()
((let* ()
expr ...)
(let ()
expr ...))
((let* ((var val) next ...)
expr ...)
(let ((var val))
(let* (next ...)
expr ...)))))
This defines let* in terms of nested lets, so that the bindings are done sequentially. It includes a base case (with no bindings), as well as a recursive case.
