Two questions about Racket macro

Question

1. About hygienic macro

   I don't fully understand how hygienic macro work. Here is two example.
   first one is:

    #lang racket
    (define-syntax (g stx)
      (syntax-case stx ()
        ([_ arg]
         #'(display arg))))

    (let ([display 1])
      (g 3))

this works fine but this one:

    #lang racket
    (define-syntax (g stx)
      (syntax-case stx ()
        ([_ arg]
         #'(display arg))))

    (define display 1)

    (g 3)

will raise an exception. How to explain the difference between the two case?

2. How to define a macro like this

   I want to define a macro to allow anonymous recursive function in racket. This one won't work because recur is not defined in the module:

    #lang racket
    (define Z
      (λ(recur)
        ((λ(x) (recur (λ(y) (x x) y)))
         (λ(x) (recur (λ(y) (x x) y))))))

    (define-syntax-rule (R proc)
      (Z (λ(recur) proc)))

    ((R (λ(n)
          (if [= n 1]
              1
              (* n (recur (- n 1)))))) 3)

How to achieve this?

Answer 1

So you want to break hygene? You need to get recur to have the lexical context of the original form such that recur will be seen as the same identifier. You can do this with datum->syntax and the result might look something like this:

(define-syntax (recur-λ stx)
  (syntax-case stx ()
    [(_ args body ...)
     (with-syntax ([recur-stx (datum->syntax stx 'recur)])
       #'(Z (λ (recur-stx)
              (λ args body ...))))]))

Now as long as your args or the nesting in body introduces recur it will work:

; multiple argument recursion
(define Z
  (λ (f)
    ((λ (g) (g g))
     (λ (g)
       (f (λ args (apply (g g) args)))))))


; ackerman    
((recur-λ (m n)
     (cond
       ((= m 0) (+ n 1))
       ((= n 0) (recur (- m 1) 1))
       (else (recur (- m 1) (recur m (- n 1))))))
 3
 6)
; ==> 509

It won't work if you make recur an argument:

((recur-λ (recur) (recur 1)) 1)
; ==> error: recur not a procedure

And of course if you make a nested binding:

((recur-λ (a) 
   (define recur a) 
   (recur 1))
 1)
; ==> error: recur not a procedure

And of course you can step through the macroexpander and it will show you that it does something like this:

(expand-once 
 #'(recur-λ (m n)
     (cond
       ((= m 0) (+ n 1))
       ((= n 0) (recur (- m 1) 1))
       (else (recur (- m 1) (recur m (- n 1)))))))

; ==>
; #'(Z
;    (λ (recur)
;      (λ (m n)
;        (cond
;         ((= m 0) (+ n 1))
;         ((= n 0) (recur (- m 1) 1))
;         (else (recur (- m 1) (recur m (- n 1))))))))

Answer 2

To answer your first question, the thing your forgetting here is that when you do a module level define like that, that definition is bound for the whole module. So, you could, theoretically write your second code block like this:

#lang racket
(let ([display 1])
  (define-syntax (g stx)
    (syntax-case stx ()
      ([_ arg]
       #'(display arg))))

  (g 3))

And now it makes sense why you get an error, because the display in your macro is bound to 1, which is not a function.

Long story short, think of hygiene just as lexical scope. Whatever display is bound to when you define your macro is what it will be. (This is opposed to macros in other languages, where whatever display is bound to when you call (or really expand) the macro, is what it will be.

Now, to answer your second question, I apologize, but am unclear what you are trying to ask here. If you could clean it up a bit then I can fill in this part of the answer.