Hi,

I want to discuss some of my experiences using the current syntax system
when making the racket match
matcher utilizing syntax-parse.

When doing this I tried to use another style of macro parsing then seen in
guiles ice-9 match e.g. Alex Shinns matcher for example. What I mean here
is that I tried to use #' #, #,@ and calling out to functions in stead of
writing one more macro. This works but it has a caveat.
Hygiene is harder to maintain. e.g.  I kept on hitting this kind of code
snippets

#'(let ((x v))
    #,(f rest #'x))

The problem with this code is hygiene, I need to make a gensym and use
with-syntax to bound x to that gensym in order to be safe
at the macro expansion. Apart from this I liked the flow of the program and
how natural it was to comprehend the code.

The downside to this style is that we looses safety with respect to hygiene
bugs. So can we improve on this. I would say yes!
Consider introduceing #. and #.@ that works very much like #, and #,@ but
with the distinction that #. creates a syntactic lambda e.g.
The construction of the syntax object translates to
#'(let ((x v)) #.(f rest #'x))

=>

#'(let ((x v)) #,(lambda (env) (with-syntax-env env (f rest #'x)))

E.g. we inject a lambda inside the syntax structure to be parsed by the
syntax expander later on and the syntax expander
will recognize the lambda and call it with the current environment of the
expander. The lambda will in turn set the syntax env that
should be used by the #'x form in order match that x with the bounded x. I
think that you get my intention.

The question is why something like this does not exists. Is it because of
weaknesses making this procedure unsound or any other reasons. I do think
such a feature would be important but on the other hand, someone should
have thought about this before and rejected the idea so my question is
simply why is this rejected any clues or pointers?

/Regards
Stefan