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. 

   Program result = read → expand → eval­uate → print.

2. 

   The reader for the language converts the surface nota­tion of the source file into S-expres­sions and returns a a new module expres­sion.

3. 

   For this reason, every source file starts with a #lang line that “boots” into the reader.

4. 

   To find the reader, Racket resolves (that is, deter­mines the path to) the module name on the #lang line and tries to load its reader submodule.

   

   Ques­tion: where is the reader located for these source files?

   #lang pollen/markdown
   Hello world

   1 2	#lang pollen/markdown Hello world

   
   #lang racket
   "Hello world"

   1 2	#lang racket "Hello world"

   
5. 

   This is the most common usage. The #lang line also supports #lang reader nota­tion that lets you set the reader to any module, including a rela­tive path, so this #lang line is equiv­a­lent to the previous:

   #lang reader (submod pollen/markdown reader)
   Hello world

   1 2	#lang reader (submod pollen/markdown reader) Hello world

   
   #lang reader (submod racket/main reader)
   "Hello world"

   1 2	#lang reader (submod racket/main reader) "Hello world"

   
6. 

   Racket expects the reader submodule to provide a func­tion called read-syntax, which accepts two input argu­ments: a source name (that holds the loca­tion of the source—e.g., for file input, the name would be a path) and an input port (that points at the source file).

   dsl/main.rkt

   #lang br
   (module reader br
     (provide read-syntax)
     (define (read-syntax name port)
       ···))

   1 2 3 4 5

   #lang br (module reader br (provide read-syntax) (define (read-syntax name port) ···))

   
   

   Ques­tion: in what sense is reader a submodule? It seems to be at the top level.

7. 

   read-syntax reads all the data from the input port (that is, until the port returns eof) and converts it into S-expres­sions:

   dsl/main.rkt

   #lang br
   (module reader br
     (provide read-syntax)
     (define (read-syntax name port)
       (define s-exprs (read-expression port))
       ···))

   1 2 3 4 5 6

   #lang br (module reader br (provide read-syntax) (define (read-syntax name port) (define s-exprs (read-expression port)) ···))

   
8. 

   read-syntax puts these S-expres­sions into a syntax object repre­senting a module expres­sion. This syntax object should not have any iden­ti­fier bind­ings. This module expres­sion must include the module that will serve as the expander.

   

   In quasiquote nota­tion:

   dsl/main.rkt

   #lang br
   (module reader br
     (provide read-syntax)
     (define (read-syntax name port)
       (define s-exprs (read-expression port))
       (datum->syntax #f
                      `(module dsl-mod-name dsl/expander
                         ,@s-exprs))))

   1 2 3 4 5 6 7 8

   #lang br (module reader br (provide read-syntax) (define (read-syntax name port) (define s-exprs (read-expression port)) (datum->syntax #f `(module dsl-mod-name dsl/expander ,@s-exprs))))

   
   

   In quasisyntax nota­tion:

   dsl/main.rkt

   #lang br
   (module reader br
     (provide read-syntax)
     (define (read-syntax name port)
       (define s-exprs (read-expression port))
       (strip-bindings
        #`(module dsl-mod-name dsl/expander
            #,@s-exprs))))

   1 2 3 4 5 6 7 8

   #lang br (module reader br (provide read-syntax) (define (read-syntax name port) (define s-exprs (read-expression port)) (strip-bindings #`(module dsl-mod-name dsl/expander #,@s-exprs))))

   
   

   In with-syntax nota­tion, using a dot:

   dsl/main.rkt

   #lang br
   (module reader br
     (provide read-syntax)
     (define (read-syntax name port)
       (define s-exprs (read-expression port))
       (strip-bindings
        (with-syntax ([EXPRS s-exprs])
        #'(module dsl-mod-name dsl/expander
            . EXPRS)))))

   1 2 3 4 5 6 7 8 9

   #lang br (module reader br (provide read-syntax) (define (read-syntax name port) (define s-exprs (read-expression port)) (strip-bindings (with-syntax ([EXPRS s-exprs]) #'(module dsl-mod-name dsl/expander . EXPRS)))))

   
   

   In with-syntax nota­tion, using an ellipsis:

   dsl/main.rkt

   #lang br
   (module reader br
     (provide read-syntax)
     (define (read-syntax name port)
       (define s-exprs (read-expression port))
       (strip-bindings
        (with-syntax ([(EXPR ...) s-exprs])
          #'(module dsl-mod-name dsl/expander
              EXPR ...)))))

   1 2 3 4 5 6 7 8 9

   #lang br (module reader br (provide read-syntax) (define (read-syntax name port) (define s-exprs (read-expression port)) (strip-bindings (with-syntax ([(EXPR ...) s-exprs]) #'(module dsl-mod-name dsl/expander EXPR ...)))))

   
   

   Ques­tion: which of these four vari­ants is the best?

   

   Ques­tion: why do we want to strip bind­ings from our module expres­sion?

9. 

   BTW, where do those bind­ings come from? When we use syntax or its vari­ants (quasisyntax, the #' prefix) to make a syntax object, it attaches the current lexical context to any parts of the object that don’t have one. If a part already has lexical context, syntax leaves it alone. Lexical context = fancy term for the set of bind­ings currently avail­able.

   (define stx #'(+ plus))
   (for ([substx (syntax->list stx)])
     #R substx
     #R (syntax->datum substx)
     #R (identifier-binding substx))

   1 2 3 4 5

   (define stx #'(+ plus)) (for ([substx (syntax->list stx)]) #R substx #R (syntax->datum substx) #R (identifier-binding substx))

   
10. 

    In Racket, this policy of preserving lexical context is called hygiene. It guar­an­tees that we can move syntax objects around without changing their meaning. But occa­sion­ally, we want to inten­tion­ally change or remove the lexical context (as in this case).

1. 

   Reads all the S-expres­sions from a source file and

2. 

   Puts them into a new module expres­sion that invokes the br expander.

test.rkt

#lang read-only

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

1 2 3 4

#lang read-only "hello world" (+ 1 (* 2 (- 3)))



"hello world"
-5

1 2	"hello world" -5

read-only/main.rkt

#lang br
(module reader br
  ···)

1 2 3

#lang br (module reader br ···)

• 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