#### 4.3.1 Binding constructs for syntactic keywords

‘`Let-syntax`’ and ‘`letrec-syntax`’ are analogous to ‘`let`’ and ‘`letrec`’, but they bind syntactic keywords to macro transformers instead of binding variables to locations that contain values. Syntactic keywords may also be bound at top level; see section Syntax definitions.

— syntax: let-syntax <bindings> <body>

> Syntax: <Bindings> should have the form

>     ((<keyword> <transformer spec>) ...)

> Each <keyword> is an identifier, each <transformer spec> is an instance of ‘`syntax-rules`’, and <body> should be a sequence of one or more expressions. It is an error for a <keyword> to appear more than once in the list of keywords being bound.

> Semantics: The <body> is expanded in the syntactic environment obtained by extending the syntactic environment of the ‘`let-syntax`’ expression with macros whose keywords are the <keyword>s, bound to the specified transformers. Each binding of a <keyword> has <body> as its region.

>     (let-syntax ((when (syntax-rules ()
>                               ((when test stmt1 stmt2 ...)
>                                (if test
>                                    (begin stmt1
>                                           stmt2 ...))))))
>            (let ((if #t))
>              (when if (set! if 'now))
>              if))                               ==>  now

>          (let ((x 'outer))
>            (let-syntax ((m (syntax-rules () ((m) x))))
>              (let ((x 'inner))
>                (m))))                           ==>  outer

— syntax: letrec-syntax <bindings> <body>

> Syntax: Same as for ‘`let-syntax`’.

> Semantics: The <body> is expanded in the syntactic environment obtained by extending the syntactic environment of the ‘`letrec-syntax`’ expression with macros whose keywords are the <keyword>s, bound to the specified transformers. Each binding of a <keyword> has the <bindings> as well as the <body> within its region, so the transformers can transcribe expressions into uses of the macros introduced by the ‘`letrec-syntax`’ expression.

>     (letrec-syntax
>            ((my-or (syntax-rules ()
>                      ((my-or) #f)
>                      ((my-or e) e)
>                      ((my-or e1 e2 ...)
>                       (let ((temp e1))
>                         (if temp
>                             temp
>                             (my-or e2 ...)))))))
>            (let ((x #f)
>                  (y 7)
>                  (temp 8)
>                  (let odd?)
>                  (if even?))
>              (my-or x
>                     (let temp)
>                     (if y)
>                     y)))                        ==>  7