RE: Hygienic macros and lexical-scoping

| > | using x val body = [| do { (var x) <- val; body; (var x).Dispose
() }
| > |]
| > | // x is of type string
| > |
| > | [| \y -> do { $(using "x" [| x |]); f y |]
| > |
| > | wouldn't work, and one would have to use gensym by his own to get
| >
| > expected
| >
| > | sematics.
| >
| > I'm sorry, I didn't understand this at all.  What is 'using x val
body'?
| > What is .Dispose()?  Not Template Haskell certainly.
| 
| Well, it supposed to be a function, which takes 'x' (of type string),
'val'
| and 'body' (being expressions) and creates code which does:
| - define local variable of name 'x' initialized with 'val'
| - execute 'body' (it is assumed to have occurrences of 'x' inside,
which
| should be captured by local 'x'
| - disposes 'x' (it has method 'Dispose', so I think its Haskell
counterpart
| would be calling function 'Dispose' on 'x')

Ah.  I thought 'using' was a keyword!  OK, so it's like this:

  foo :: String -> Q Exp -> Q Exp -> Q Exp
  foo x val body = [| do { $(mkName x) <- $val; $body; dispose $(dyn x)
} |]

Here, 	mkName :: String -> Name

	dyn :: String -> Q Exp
	dyn s = return (Var (mkName s))

and I'm assuming an as-yet-unimplemented feature of TH which lets you
splice a Name into a binding position (thus ($n <- ...)  or (\$n ->
...)).



The binding $(mkName x) certainly captures the occurrence $(dyn x).  But
you also want to capture some occurrences of 'x' in 'body'.   Thus,
consider

	foo "wug" [| 77 |]  [| wug > 2 |] 

does the 'wug' in 'wug > 2' get captured by the (mkName "wug") binding?
No, not in TH.  The above call is statically rejected unless wug is
already in scope.  For example
	let wug = 88 in 
	foo "wug" [| 77 |]  [| wug > 2 |]

And in this case, the 'wug > 2' is indissoubly bound to the 'wug = 88'
binding.  

What if you *want* the 'wug > 2' to be bound un-hygienically to the
(mkName "wug") binding?  Then use 'dyn' thus

	let wug = 88 in 
	foo "wug" [| 77 |]  [| $(dyn "wug") > 2 |]

Now, plainly, the wug=88 binding plays no role.

| This can be implemented in TH with (dyn "x") which you mentioned, but
if
| 'body' is itself passed from another context and 'x' is introduced in
| 
| f body = [| using "x" Foo $( [| do { dosomething x; body } |] ) |]
| 
| then some external 'x' in original 'body' might get catched by dynamic
| binding, which is not hygienic behavior.
| 
| I'm aware that this can be workaround with manually creating 'x' with
newName
| and using this Name. Our decision to bind variables after macros
expansion
| makes it possible to handle such cases in other way. There are
opposite
| design goals, and I clearly see advantage of TH's one - bind to what
you can
| see, before any expansion. Nevertheless we will try another approach
and
| experiment with such system.

I hope the above makes it clear that you can express either behaviour in
TH.

To be sure, the references to dynamically scoped things are
inconvenient, as we see in $(dyn "wug") > 2, but at least there's a
simple story to tell.

| see, before any expansion. Nevertheless we will try another approach
and
| experiment with such system.

Indeed -- this is a rather complex design space, so it's great to
explore new parts of it.

Simon