Marc Nieper-Wißkirchen <xxxxxx@nieper-wisskirchen.de> schrieb am Sa., 22. Juli 2017 um 13:16 Uhr:

For R7RS-large we can look forward and add a let(rec)-syntax/splicing.

There are some edge cases that might need specification, though:

(let ()
(let-syntax/splicing ((foo (syntax-rules () ((foo) 'foo)))
(define-syntax foo (syntax-rules () ((foo) 'bar)))
(foo)))

Does this evaluate to foo, bar, or is it an error?

If we want to be able express the (non-splicing) let(rec) in terns of let(rec)-splicing by using the simple transformation

(let(rec)-syntax <bindings> <body>) => (let () (let(rec)-syntax/splicing <bindings> <body>),

the snippet from above will have to evaluate to bar.

Now, consider the following example:

(let ()
(let-syntax/splicing ()
(define let-syntax/splicing #f)
#f))

This must be possible if we want this snippet to behave as a non-splicing let-syntax. It would, however, be violation of 5.4 of the R7RS, where is says:

"Macros can expand into definitions in any context that
permits them. However, it is an error for a definition to
define an identifier whose binding has to be known in order
to determine the meaning of the definition itself, or of
any preceding definition that belongs to the same group
of internal definitions. Similarly, it is an error for an internal
definition to define an identifier whose binding has
to be known in order to determine the boundary between
the internal definitions and the expressions of the body it
belongs to."

So I would like to see clear semantics for let(rec)-syntax/splicing that is in accordance with the rest of the R7RS. Possibly, let(rec)-syntax (non-splicing) won't be implementable with let(rec)-syntax/splicing then, meaning that we actually have too different binding constructs neither of which is expressible in terms of the other.

This is wrong. We can actually express let(rec)-syntax in terms of let(rec)-syntax/splicing but not with the transformation

(let(rec)-syntax <bindings> <body>) => (let () (let(rec)-syntax/splicing <bindings> <body>)

given above.

The correct transformation is

(let(rec)-syntax <bindings> <body>) => (let(rec)-syntax/splicing <bindings> (let () <body>))

This works even in the edge cases where <body> contains definitions redefining let(rec)-syntax/splicing, and irregardless of the particular semantics of let(rec)-splicing in these edge cases.

Note that I assume that let is inserted by a hygienic macro transformer and not shadowed by any of the <binding>s.

Marc