0. #lang racket
1.  
2. (require (for-syntax racket/syntax
3.                      syntax/transformer)
4.          syntax/parse/define)
5.  
6. (begin-for-syntax
7.   (define (exp stx) (local-expand stx 'expression '()))
8.  
9.   (define current-id (make-parameter #f))
10.  
11.   (define walk+expand
12.     (syntax-parser
13.       #:literals [#%plain-app @%bind-id @%use-id]
14.       #:context 'walk+expand
15.       [(#%plain-app @%bind-id ~! e:expr)
16.        #'(let-syntax
17.              ([result-transformer
18.                (let ([id-to-bind (generate-temporary 'the-binding)])
19.                  (make-variable-like-transformer
20.                   (parameterize ([current-id id-to-bind])
21.                     (exp (walk+expand (exp #`(λ (#,id-to-bind) e)))))))])
22.            result-transformer)]
23.       [(@%plain-app @%use-id ~!)
24.        #'(let-syntax
25.              ([result-transformer
26.                (make-variable-like-transformer
27.                 (current-id))])
28.            result-transformer)]
29.       [(a . b) (datum->syntax this-syntax
30.                               (cons (walk+expand #'a) (walk+expand #'b))
31.                               this-syntax
32.                               this-syntax)]
33.       [_ this-syntax])))
34.  
35. (define-syntax-parser do-walk+expand
36.   [(_ e:expr)
37.    (walk+expand (exp #'e))])
38.  
39. (define (@%bind-id . args) (error '@%bind-id "should never persist until runtime"))
40. (define (@%use-id . args) (error '@%use-id "should never persist until runtime"))
41.  
42. (do-walk+expand
43.  (@%bind-id (+ 1 (@%use-id))))

=>

program::-1: syntax-parser: literal is unbound in phase 0

(phase 0 relative to the enclosing module)

at: %bind-id

in: (syntax-parser #:literals (#%plain-app %bind-id

%use-id) #:context (quote walk+expand) ((#%plain-app

%bind-id ~! e:expr) (syntax (let-syntax ((result-transformer

(let ((id-to-bind (generate-temporary (quote the-binding))))

(make-variable-like-transforme...