On 08/25/2012 01:57 PM, Neil Toronto wrote:
On 08/25/2012 11:33 AM, Ryan Culpepper wrote:
On 08/25/2012 01:08 PM, Neil Toronto wrote:
A number can expand to an arbitrary expression? How?
And what do you mean by "the '#%datum' macro associated with them"?
Applied to them?
> (let-syntax ([#%datum (lambda (stx) #'(printf "hello\n"))]) 5)
hello
In Racket, literal data carry lexical information just like identifiers.
When a literal datum is used as an expression, the macro expander
synthesizes a '#%datum' identifier that determines what to do with the
literal. The Racket '#%datum' macro just expands into a 'quote'
expression if the datum is not a keyword.
The implicit '#%app' syntax works similarly, except it takes its lexical
context from the pair that represents the application.
Holy heck I had no idea. That's awesome and scary.
So this is what I have now:
(define skip-ids
(syntax->list #'(+ - * / < > <= >= = min max)))
(define (skip-binding? e-stx)
(let ([e-stx (local-expand e-stx 'expression #f)])
(and (identifier? e-stx)
(findf (λ (skip-id) (free-identifier=? skip-id e-stx))
skip-ids))))
I would have called it safe before today, but I knew fewer awesome and
scary things. Does it look safe to you?
In this case you can get rid of the 'local-expand', since you're only
looking for references to particular variables.
If you do keep the 'local-expand', you should use the result in the code
your macro produces so that the expression isn't expanded multiple
times. For example:
(define-syntax (m stx)
(syntax-case stx ()
[(m e stuff ...)
(let ([ee (local-expand #'e 'expression #f)])
(if (and (identifier? ee)
(for/or ([skip-id skip-ids])
(free-identifier=? ee skip-id)))
#`(real-m #,ee stuff ...)
#`(let ([tmp #,ee])
(real-m tmp stuff ...))))]))
Depending on exactly what you're doing, you might want an empty stop
list instead of #f. Or you might want to use
'syntax-local-expand-expression' instead so that the expander doesn't
have to retraverse the expanded expression.
--
In other words, a macro's subexpressions should be used linearly (as in
"linear types"). Putting an expression in the macro's result in an
expression context counts as a use. (But putting it in the result in a
quoted context doesn't.) Calling 'local-expand' or
'syntax-local-expand-expression' on it also counts as a use, but it
gives back another linearly-restricted expression. (The same applies to
definitions; I should really say all "forms" should be used linearly.)
Ryan
_________________________
Racket Developers list:
http://lists.racket-lang.org/dev
