Per Bothner skrev:
A problem with define-syntax+syntax-case is that you
get very verbose syntax definitions, with lots of
standard boiler-plate. This makes syntax definitions
needlessly hard to read and (less important) more tedious to
write. This has tempted some of my Kawa users to use the "legacy"
non-hygienic define-macro form, even though I discourage it.
Even plain R5RS define-syntax+syntax-rules is
ridiculously verbose.
One idea I had has this little conveniece macro:
(define-syntax define-syntax-case
(syntax-rules ()
((define-syntax-case name literals . parts)
(define-syntax name
(lambda form
(syntax-case form literals . parts))))))
Typical use - especially nice if #` is availiable:
(define-syntax-case NAME ()
((_ PVAR ...)
#`(... PVAR ...))
Of course people can define this themselves, but
it is nicer if it is standard, because then people
get used to reading it.
I assume the standard boiler plate you are thinking
of is
(define-syntax foo
(lambda (stx)
(syntax-case stx ()
<clauses>)))
?
In analogy with
(define (foo x)
== (define foo (lambda (stx) ...))
a common extension to define-syntax is
(define-syntax (foo stx)
== (define-syntax foo (lambda (stx) ...))
The "standard boiler plate" then becomes
(define-syntax (foo stx)
(syntax-case stx ()
<clauses>))
This is almost as short as your convenience macro and at
the same time still makes it possible to refer to the original
input syntax-object of the transformer. Refering to the
original piece of syntax is often neccessary in order to give
error messages in terms of user written syntax.
I agree with you that the common case should be convenient
to write, in this case I'm not sure I think it is worth
introducing an extra binding form in order to save relatively
few key strokes.
--
Jens Axel Søgaard