If we would write the above using #` and #, in racket and guile that would produce 1 in stead.

This construction can probably be styled more simply by assuming the variable bindings implicitly and
realized by hacking psyntax (which I do not want to do to show the semantics) so ideally I would have likedto write #.(f #'x) as a cleaner form.

I do know that writing macro expansions in this way is considered bad style but do not know why. I tend to like the
idea of writing macro expansions with a minimum of helper macros, The fact that you need a lot of helper macroswhen writing for example a matcher in the traditional style with e.g. syntax-rule is something I view as unclean
and limiting.

My ideal of handling for example an implementation of the racket macther, see

Is using syntax-parse to destruct the code in it's components and
then build up the resulting expansion using functions and making heavy
use of #` and friends. Testing this approach I got into problems with
capturing variable bindings in the spirit of the above example,
and the solution at that time was to go back with Common Lisp like
gensyming. A better solution would be to use ##` and #. in stead for a
cleaner and more (I believe) syntactically correct solution. Anyhow what
do you think about introducing these constructs in a more un hackky way
to scheme in general (at least those using psyntax and similar macro
systems) in order to let people code more safely with the suggested
style.

How is this style differnt from using macros? It allows the construction flow with many different channels ofinformation, channels that is non syntax and channels that are syntax objects! It have the functional applicational
semantic.

Anyhow I would like to try to lift this semantic to a more general platform if possible cause I find it a really nifty feature.