

The Underbelly of Racket Macro Basics - nickmain
http://jeapostrophe.github.io/2013-07-22-123list-post.html

======
idoh
I've been trying to learn Racket macros but articles like this make me feel
like I should just give up. For example, in arc a macro looks like this:

    
    
      (mac awhen (expr . body)
        `(let it ,expr (if it (do ,@body))))
    

I can understand that, and start making macros and going about my business.
The Racket guys (e.g. Eli and Jay) write macros that look like this:

    
    
      (require (lib "stxparam.ss" "mzlib"))
      (define-syntax-parameter it
        (lambda (stx)
          (raise-syntax-error #f "can only be used inside `if'" stx)))
      (define-syntax if*
        (syntax-rules ()
          [(if*) (void)]
          [(if* X) X]
          [(if* C X more ...)
           (let ([b C])
             (if b
               (syntax-parameterize ([it (make-rename-transformer #'b)]) X)
               (if* more ...)))]))
    

Or like this:

    
    
      (define-syntax (123-list stx)
      (define middle-x-stx (second (syntax->list stx)))
      (define x-id (syntax-e middle-x-stx))
      (define new-ctxt-stx (datum->syntax #f 'new-ctxt))
      (datum->syntax
       new-ctxt-stx
       (list (datum->syntax #'123-list 'let)
             (list (list x-id (datum->syntax #'123-list 3)))
             (list (datum->syntax #'123-list '#%app)
                   (datum->syntax #'123-list 'list)
                   (datum->syntax #'123-list x-id)
                   middle-x-stx
                   x-id))))
    

They have reasonable objections to arc-style macros, but I feel like they are
overly academic and not relevant to the programming problems that I want to
address. I want to eliminate boilerplate, and I'm willing to take the
limitations of arc-style macros because they are so much easier to understand.

~~~
mordae
Your code (`when` that binds `it`) translates to:

    
    
      (define-syntax (awhen stx)
        (syntax-case stx ()
          ((_ expr body ...)
           (with-syntax ((it (datum->syntax stx 'it)))
             #`(let ((it expr))
                 (when it body ...))))))
    

I find it a bit hairy, but mostly sane. It's all about being hygienic. Notice
how you explicitly place the `it` identifier into the caller's context but
keep the usual let and when?

------
gtani
I just noticed _Realm of Racket_ in my local bookstore a few days ago. Haven't
had time to peruse, but looks good, a dozen pages on macros

[http://nostarch.com/realmofracket](http://nostarch.com/realmofracket)
(download a chapter, index and ToC)

_______________________________________

also, on the openJDK list, they're looking at Clements/Felleisen's tail call
writeup from 2004

[http://mail.openjdk.java.net/pipermail/mlvm-
dev/2013-July/00...](http://mail.openjdk.java.net/pipermail/mlvm-
dev/2013-July/005417.html)

