Keith Wright wrote:

>>As an example of a macro written using normal Scheme operators and
>>these syntactical abbreviations, I have taken the macro do-primes
>>from "Practical Common Lisp" p. 94.
>
> I do not see the point of this example.
> I just ran the following through the SRFI reference implementation,
> it works fine.

That's (part of) the point. Felix asked:

   But wouldn't this completely break the (IMHO) rather practical ability
   to destructure arguments passed to macros via normal Scheme operators?
   What I like about srfi-72 is that I can write hygienic macros with
   (nearly) the same ease as in conventional Lisp-/quasiquote-style. In
   fact this is what I consider the most innovative feature for SRFI-72.

So the do-primes example shows that the abstract approach too allows
for i) destructuring with normal Scheme operations and ii) that
macros can be written in the traditional quasiquote-style.

> The template
> happens to be a loop, but so what?
> A more interesting example would do the loop in the macro expander.
> I don't have time right now to work up a prime example, but here
> is one I have laying about:
>
> (define-syntax define-count
>   (lambda (form)
>       #`,(let loop ((names (cdr form))
>                     (k 0)
>                     (result '()))
>            (if (null? names)
>                (quasisyntax (begin ,@result))
>                   (loop (cdr names)
>                         (+ k 1)
>                         (cons #`(define ,(car names) ,k))
>                               result)))))

Adding one syntax->list and replacing , and ,@ with
#, and #,@ one gets:

(define-syntax define-count
   (lambda (form)
       #`#,(let loop ((names (cdr (syntax->list form)))
                      (k 0)
                      (result '()))
             (if (null? names)
                 (quasisyntax (begin #,@result))
                 (loop (cdr names)
                       (+ k 1)
                       (cons #`(define #,(car names) #,k)
                             result))))))

which runs in DrScheme.

For fun, here is a syntax-case version:

(require-for-syntax (lib "list.ss" "srfi" "1"))
(define-syntax (define-count stx)
   (syntax-case stx ()
     [(define-count name ...)
      (with-syntax ([(count ...)
                     (iota (length (syntax->list #'(name ...))))])
        #'(begin
            (define name count)
            ...))]))

>>A macro whose expansion uses quasiquote to construct a list can
>>be hard to read (and write), if ordinary lists are used to represent
>>syntax. It is not immediately obvious whether a given quasiquote
>>is used to construct the expansion or is a part of the expansion
>>of a call to the macro.
>
> Indeed, nested quasiquote is notoriously mind-bending.
> What part of the SRFI should be changed to fix that?
> How does a lot of syntax->list help?

It isn't syntax->list that help.

Spotting #' or #` signals that here a piece of code is constructed.
Spotting  ' or  ` signals that a list will be constructed, when
the expanded code is run.

--
Jens Axel Søgaard