On Apr 27, 2016, at 12:30 PM, Alex Knauth <[email protected]> wrote:
>
> Well, it's not even that. This doesn't work:
> (let ()
> (define-sli-foo)
> (let ()
> (invoke-sli-foo)))
Based on that, here's simpler example of why I find `syntax-local-introduce`
confounding.
It seems to break the #1 rule of hygienic macros — that macro-introduced
identifiers retain their bindings from the macro-definition site — merely by
proximity.
Consider the examples below. The `invoke-foo` macro introduces `foo`, which, by
the #1 rule, ought to refer to the `foo` function defined nearby.
Example A: `invoke-foo` relies on the hygienic `foo` reference. As we would
expect.
Example B: But when `define-sli-foo` is used next to `invoke-foo`,
`define-sli-foo` somehow manages to rebind the `foo` identifier inside
`invoke-foo`.
Example C: As Alex points out, when `invoke-foo` is moved into a sub-`let`,
hygiene is restored (even though we'd ordinarily expect `define` bindings to
carry through).
Makes me nostalgic for the good old days of `datum->syntax` ...
;;;;;;;;;;
#lang racket
(define (foo) 'hygienic-func)
(define-syntax-rule (invoke-foo) (foo))
(define-syntax (define-sli-foo stx)
(syntax-case stx ()
[(_)
(with-syntax ([sli-foo (syntax-local-introduce #'foo)])
#`(begin
(define (sli-foo) 'sli-func)))]))
(module* test #f
(require rackunit)
;; example A
(check-equal? (invoke-foo) 'hygienic-func) ; yes of course
;; example B
(check-equal?
(let ()
(define-sli-foo)
(invoke-foo)) 'sli-func) ; um, why?
;; example C
(check-equal?
(let ()
(define-sli-foo)
(let ()
(invoke-foo))) 'hygienic-func)) ; gaah why?!?!?!?
--
You received this message because you are subscribed to the Google Groups
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/d/optout.