R4RS Appendix  (define-syntax <keyword> <transformer>)     ==>  unspecific
S9fES          (define-syntax <symbol> <procedure>)        ==>  unspecific
S9fES          (define-syntax (<sym1> <sym2> ...) <body>)  ==>  unspecific

Syntax: The <keyword> is an identifier, and <transformer> should be
an instance of SYNTAX-RULES.

Semantics: The top-level syntactic environment is extended by binding
the <keyword> to the specified transformer.

(define-syntax let*
  (syntax-rules ()
    ((let* () body1 body2 ...)
     (let () body1 body2 ...))
    ((let* ((name1 val1) (name2 val2) ...)
       body1 body2 ...)
     (let ((name1 val1))
       (let* ((name2 val2) ...)
         body1 body2 ...)))))

In addition to the above the DEFINE-SYNTAX implementation of S9fES
allows to bind an ordinary procedure to a syntactic keyword. Its forms
are similar to those of DEFINE. The first form binds a <symbol> to a
<procedure>, which is specified as its second argument. The other form
binds <sym1> to the form

(lambda (<sym2> ...) <body>).

The procedures bound by DEFINE-SYNTAX may be variadic.

Procedures bound by DEFINE-SYNTAX are commonly called "macros". They
receive their arguments in textual (unevaluated) form and they are
called at macro expansion time, i.e. after reading a program but
before evaluating it. When an expression containing a macro application
is being expanded, the macro is applied to its arguments and the
application of the macro is replaced by the value returned by the
macro.

(define-syntax when
  (lambda (pred . conseq)
    `(if ,pred (begin ,@conseq))))

(when (= 1 1)
      (display "true")
      #t)               ==>  #t

Macros may not recurse directly, but they may implement recursion
internally using LETREC or by rewriting their own applications. The
following macro, for example, does not work, because D is undefined
in the body of D:

(define-syntax (d x) (and (pair? x) (d (cdr x)))) ; WRONG!

The following version does work, though, because the macro gets
rewritten to another application of itself, which is subsequently
being expanded:

(define-syntax (d x) (and (pair? x) `(d ,(cdr x)))) ; OK
