Another attempt at this old thing -- the idea of having some internal
`#%begin' thing (see ancient context below):
`begin' is something that is not only a ";" because of how it
sequences things, it's also a "return" thing -- it can be read as
(begin x ... y) ~ { x; ...; return y; }. So maybe a `#%begin' should
take its context from its last expression?
It looks to me like this could be a similar case to `#%app' usually
doing the right thing, and easy to resolve when it isn't, as in
converting a macro like
(define-syntax-rule (noisy x ...)
(begin (displayln 'start) x ... (displayln 'start)))
to:
(define-syntax-rule (noisy x ...)
(begin (displayln 'start) (begin x ...) (displayln 'start)))
On July 7th 2010, Matthew Flatt wrote:
>
> An Implicit Internal-Definitions Form
> -------------------------------------
>
> Many forms --- including `lambda' `let', and the function-shorthand
> variant of `define' --- support internal definitions. The handling
> of internal definitions is currently tired to the form.
>
> An alternative would be to have those forms implicitly wrap a group
> of internal-definition forms with `#%body', in much the same way
> that an application form is converted to a use of `#%app'. Then, the
> treatment of internal definitions could be independently configured
> through a module import. For example, one module might use a
> `#%body' that corresponds to the old handling of internal
> definitions, while another module could import a `#%body' that
> corresponds to the new handling.
>
> Setting aside the backward-compatibility issues of adding an
> implicit form, I think it turns out not to work as well as
> `#%app'. The problem is that there's not a good place to get the
> lexical context to use for the implicit `#%body'. We have many
> macros analogous to
>
> (define-syntax-rule (squawk body ...)
> (begin
> (displayln "squawk!")
> (let () body ...)))
>
> If you take the lexical context from the parentheses that surround
> the `let' form, then the `#%body' is drawn from the context of the
> `squawk' definition, while the intent was more likely to get it from
> the use of `squawk'. Meanwhile, the `body ...' sequence itself
> doesn't necessarily have a lexical context (since it doesn't have a
> parenthesis, roughly), and the sequence is recreated by the macro
> implementation anyway.
>
> This problem happens occasionally with `#%app'. When a use of
> identifier macro expands in an application position, for example,
> the implementor of the identifier macro usually should copy the
> lexical context of the old application form to the expansion
> result. Such cases are more rare than examples like `squawk',
> though.
>
> So, an implicit `#%body' form seems like a good idea in principle,
> but it doesn't seem to work out well with our current syntax. I'm
> currently inclined to not change Racket and to treat this as
> something to support better the next time we define a core syntax,
> but I'm interested in further discussion.
--
((lambda (x) (x x)) (lambda (x) (x x))) Eli Barzilay:
http://barzilay.org/ Maze is Life!
_________________________
Racket Developers list:
http://lists.racket-lang.org/dev
