Beau­tiful Racket / racket school 2019

• 1 intro
• 2 pl check­list
• 3 lop till you drop
• 4 lop exam­ples
• 5 bullet train
• 6 trigram
• 7 flyover country
• 8 read only
• 9 expand only
• 10 conjunc­tion
• 11 injunc­tion

1. 

   At the end of the reader phase, the source code has been converted into a module expres­sion that contains S-expres­sions, but has no bind­ings, e.g.—

   test.rkt

   (module dsl-mod-name dsl/expander
     dsl-sexprs ···)

   1 2	(module dsl-mod-name dsl/expander dsl-sexprs ···)

   
2. 

   The expander provides the initial set of bind­ings for the module expres­sion returned by the reader, thereby deter­mining the meaning of the iden­ti­fiers within the S-expres­sions. This, in turn, allows the expres­sions to be eval­u­ated as Racket code.

3. 

   Any module can be used as the expander for a language. It’s invoked by the first line of the module code returned by the reader. For instance, this module expres­sion will rely on dsl/expander as its expander:

   test.rkt

   (module dsl-mod-name dsl/expander
     dsl-sexprs ···)

   1 2	(module dsl-mod-name dsl/expander dsl-sexprs ···)

   
   

   Ques­tion: why don’t we use the #lang nota­tion in a module expres­sion?

   

   In essence, the expander name is like an implied require at the begin­ning of the module:

   (module dsl-mod-name _
     (require dsl/expander)
     dsl-sexprs ···)

   1 2 3

   (module dsl-mod-name _ (require dsl/expander) dsl-sexprs ···)

   
   

   Ques­tion: why can’t require actu­ally replace the expander?

4. 

   Every module used as an expander must provide a #%module-begin macro, which will be the first thing invoked in the expander. #%module-begin must accept as input all the expres­sions that appear in the body of the module expres­sion returned by read-syntax.

5. 

   To start the expan­sion, Racket imports the #%module-begin from the expander spec­i­fied in the module expres­sion. It replaces the module expres­sion with a call to this #%module-begin, passing it all the parsed expres­sions that are in the body of the module expres­sion. So this:

   test.rkt

   (module dsl-mod-name dsl/expander
     dsl-sexprs ···)

   1 2	(module dsl-mod-name dsl/expander dsl-sexprs ···)

   
   

   Becomes this:

   test.rkt

   (module dsl-mod-name dsl/expander
     (#%module-begin ;; imported from `dsl/expander`
       dsl-sexprs ···))

   1 2 3

   (module dsl-mod-name dsl/expander (#%module-begin ;; imported from `dsl/expander` dsl-sexprs ···))

   
6. 

   Often, the #%module-begin for a language will perform some language-specific processing on the parse tree, and then call the #%module-begin in the imple­men­ta­tion language. To prevent name­space colli­sions between the two #%module-begin macros, use rename-out:

   dsl/expander.rkt

   #lang br/quicklang
   (define-macro (dsl-module-begin EXPR ...)
     #'(#%module-begin ;; from `br/quicklang`
        EXPR ...))
   (provide (rename-out [dsl-module-begin #%module-begin]))

   1 2 3 4 5

   #lang br/quicklang (define-macro (dsl-module-begin EXPR ...) #'(#%module-begin ;; from `br/quicklang` EXPR ...)) (provide (rename-out [dsl-module-begin #%module-begin]))

   
7. 

   The define-macro form intro­duces a macro rather than an ordi­nary func­tion. The first line contains a syntax pattern that binds pattern vari­ables, which must be in UPPERCASE, but their names are other­wise arbi­trary. If the input to the macro doesn’t match the pattern, the macro raises an error.

8. 

   These pattern vari­ables can (only) be used in syntax templates, including the syntax template that gener­ates the syntax object returned by the macro.

   

   Here, THING is a pattern vari­able used in two syntax templates:

   #lang br
   (define-macro (mac THING)
     (println #'THING)
     #'(list THING THING))
   (mac (list "foo" 42))

   1 2 3 4 5

   #lang br (define-macro (mac THING) (println #'THING) #'(list THING THING)) (mac (list "foo" 42))

   
   

   But unlike a vari­able, THING cannot be used on its own:

   #lang br
   (define-macro (mac THING)
     (println THING) ; error
     #'(list THING THING))
   (mac (list "foo" 42))

   1 2 3 4 5

   #lang br (define-macro (mac THING) (println THING) ; error #'(list THING THING)) (mac (list "foo" 42))

   
9. 

   The initial syntax pattern can contain literal values (which must match liter­ally, of course) and sublists:

   #lang br
   (define-macro (mac2 (LEFT 42 RIGHT))
     #'(list LEFT RIGHT))
   (mac2 ("foo" 42 "bar"))

   1 2 3 4

   #lang br (define-macro (mac2 (LEFT 42 RIGHT)) #'(list LEFT RIGHT)) (mac2 ("foo" 42 "bar"))

   
   

   Ques­tion: why does the input (mac2 (list "foo" 42 "bar")) raise an error?

10. 

    The ellipsis matches a series of input argu­ments, and then denotes a “step and repeat” oper­a­tion in the syntax template:

    #lang br
    (define-macro (mac3 NUM ...)
      #'(begin (* NUM 100) ...))
    (mac3 10 42 325)

    1 2 3 4

    #lang br (define-macro (mac3 NUM ...) #'(begin (* NUM 100) ...)) (mac3 10 42 325)

    
    

    Ques­tion: what if you want to handle the first element sepa­rately?

1. 

   Converts every number into 42.

2. 

   Converts every string into "whee".

3. 

   Converts every other expres­sion into 'kaboom.

4. 

   And other­wise preserves the list struc­ture of the program.

test.rkt

#lang s-exp expand-only

"hello world"
(+ 1 (* 2 (- x)))

1 2 3 4

#lang s-exp expand-only "hello world" (+ 1 (* 2 (- x)))



"whee"
'(kaboom 42 (kaboom 42 (kaboom kaboom)))

1 2	"whee" '(kaboom 42 (kaboom 42 (kaboom kaboom)))

expand-only/main.rkt

#lang br

(define-macro (my-module-begin EXPR ...)
  #'(#%module-begin
     ···))
(provide (rename-out [my-module-begin #%module-begin]))

1 2 3 4 5 6

#lang br (define-macro (my-module-begin EXPR ...) #'(#%module-begin ···)) (provide (rename-out [my-module-begin #%module-begin]))

• 1 intro
• 2 pl check­list
• 3 lop till you drop
• 4 lop exam­ples
• 5 bullet train
• 6 trigram
• 7 flyover country
• 8 read only
• 9 expand only
• 10 conjunc­tion
• 11 injunc­tion