0. #lang racket
1. (require racket/splicing racket/stxparam)
2. (require (for-syntax syntax/parse racket/format))
3.  
4. ;;;
5. ;;; IMPLEMENTED
6. ;;;
7.  
8. ;;; This program implement three forms:
9. ;;;   (declare x)              that declares that the symbol x is the name of a variable
10. ;;;   vars                     which evaluates to a list of all declared variables
11. ;;;                            at the point, where vars occurs
12. ;;;   (let-var (x ...) body)   a local declaration, where the symbols x ...
13. ;;;                            are declared in body, but not outside.
14.  
15. ;;; Example
16.  
17. ; Form:                               Result:
18. ;   vars                               ()
19. ;   (declare x)
20. ;   vars                               (x)
21. ;   (let-var (y) vars)                 (y x)
22. ;   vars                               (x)
23. ;   (let-var (y) (let-var z 1) vars)   (y x)
24.  
25. ;;;
26. ;;; PROBLEM
27. ;;;
28.  
29. ; i) How can I extend the definition of declare in order to
30. ;    support declarations in a internal definition context?
31.  
32. ; That is, is there a way to get this interaction:
33.  
34. ; Form:                                                 Result:
35. ;   vars                                                 ()
36. ;   (declare x)
37. ;   vars                                                 (x)
38. ;   (let () (declare y) vars)                            (y x)
39. ;   vars                                                 (y)
40. ;   (let ()
41. ;     (declare y)
42. ;     (let () (declare z) 1)
43. ;     vars)                                              (y x)
44.  
45.  
46. (begin-for-syntax
47.   ; Global variables are simply stored in a compile time variable
48.   (define globals '()))
49.  
50. ; At expansion start there is only global variables, so
51. ; vars simply returns a quoted copy of the symbols collected in globals
52. (define-syntax-parameter vars (λ(stx) #`'#,globals))
53.  
54. ; Local variables on the other hand must be kept in a syntax parameter
55. ; to keep the list of locally declared variable around at syntax transformation time.
56. (define-syntax-parameter locals '())
57.  
58.  
59. (define-syntax (orig-declare stx)
60.   ; A simple version of declare (here named orig-declare) simply adds
61.   ; declared variables to the global list.
62.   (syntax-parse stx
63.     [(_ v)
64.      (define var (syntax->datum #'v))
65.      (unless (member var globals)
66.        (set! globals (cons var globals)))
67.      #'(void)]))
68.  
69.  
70. ; The following tests reveals that everything works as expected:
71.  
72. ; Expression     Expected
73. vars                ;  ()
74. (orig-declare x)    ;
75. vars                ;  (x)
76. (orig-declare x)    ;
77. vars                ;  (x)
78. (orig-declare y)    ;
79. vars                ;  (y x)
80.  
81.  
82. ; Locally declared variables are implemented using syntax-parameterize.
83. ; Both the user facing syntax   vars  and the list of locally
84. ; declared are adjusted with the help of syntax-parameterize.
85.  
86. ; (let-var (var ...) body ...)
87. ;   evaluate body in an environment where var ... are declared variables
88. (define-syntax (let-var stx)
89.   (syntax-parse stx
90.     [(_ () body ...)
91.      #'(let () body ...)]
92.     [(_ (v:id vs:id ...) body ...)
93.      (let ()
94.        (define var (syntax->datum #'v))
95.        (define old-locals (syntax-parameter-value #'locals))
96.        (define new-locals (cons var old-locals))
97.        #`(syntax-parameterize ([vars (λ (stx) #''#,(append new-locals globals))])
98.            (syntax-parameterize ([locals '#,new-locals])
99.              (let-var (vs ...) body ...))))]))
100.  
101.  
102. ; Expression                             Expected
103. (let-var (a) vars)                    ;  (  a y x)
104. (let-var (a b) vars)                  ;  (b a y x)
105. (let-var (a) (let-var (b) vars))      ;  (b a y x)
106. (let-var (a) (let-var (b) 7) vars)    ;  (  a y x)
107.  
108.  
109. ;;;
110. ;;; The hope was to copy the ideas used in let-var to implement
111. ;;; declarations in an internal definition context.
112.  
113. ;;; The point where I am stuck:
114. ;;;   syntax-parameterize can adjust the meaning of locals and vars in a given body
115. ;;;   But in an internal definition context, the meaning of locals and vars
116. ;;;   must be adjusted in the rest of the internal definition context,
117. ;;;   so at the point where (declare x) is expanded, there is no access to the "body".
118.  
119. (define-syntax (declare stx)
120.   (syntax-parse stx
121.     [(_ v)
122.      (define var (syntax->datum #'v))
123.      (define ctx (syntax-local-context))
124.      (cond
125.        [(eq? ctx 'top-level)
126.         ; outside any module, definition or expression
127.         ; (except as a subsexpression in a top-level begin)
128.         ; i.e. think repl...
129.         (error 'declare "the top-level context not supported (yet?)")]
130.        [(eq? ctx 'module-begin)
131.         ; inside the body of a module as the only form within the module
132.         (error 'declare "the module-begin context not supported (yet?)")]
133.        [(eq? ctx 'expression)
134.         ; in a context where only expressions are allowed
135.         (error 'declare "declarations can not appear as expressions")]
136.        [(eq? ctx 'module)
137.         ; in a module (inside the module-begin layer)
138.         (unless (member var globals)
139.           (set! globals (cons var globals)))
140.         #'(void)]
141.        [(list? ctx) ; internal definition context
142.         ; in a nested context that allows both definitions and expressions
143.         ; e.g. the body of a let expression is an internal definition context
144.         ; For let and friends, a defintion in an internal definition context
145.         ; is a equivalent to local binding via letrec-syntaxes+values.
146.         ; Each body is partially expanded into one of:
147.         ;   i) define-values
148.         ;  ii) define-syntaxes
149.         ; iii) primitive expression other than begin
150.         ;  iv) a begin form (which is spliced in, and the newly-spliced subforms
151.         ;      are also partially expanded)
152.         ; The definitions and expressions are then rewritten into a letrec-syntaxes+values form
153.  
154.         ; Note: A (define-syntax-parameter ...) expands into define-syntaxes.
155.         ;       But what about syntax-parameterize ?
156.         (define var (syntax->datum #'v))
157.         (define old-locals (unbox (syntax-parameter-value #'locals)))
158.         (define new-locals (cons var old-locals))
159.         (displayln new-locals)
160.         #'(void) ; <- What to write here?
161.         ]
162.        [else (error 'declare (~a "expansion reached unhandled expansion context " ctx))])]))

=>