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 (pronounced hash-lang) that “boots” into the reader.

4. 

   The module is the basic orga­ni­za­tional unit of code in Racket. A module expres­sion includes a name, an expander, and a body containing other S-expres­sions:

   (module module-name expander
      other-expressions
      to-expand
      and-evaluate ...)

   1 2 3 4

   (module module-name expander other-expressions to-expand and-evaluate ...)

   
5. 

   Modules can also contain other modules. These are called, unsur­pris­ingly, submod­ules, and they are loaded inde­pen­dently of their enclosing module:

   (module module-name expander
      other-expressions
      to-expand
      and-evaluate ···
     (module submodule-name submodule-expander
       more-expressions ···))

   1 2 3 4 5 6

   (module module-name expander other-expressions to-expand and-evaluate ··· (module submodule-name submodule-expander more-expressions ···))

   
6. 

   Every Racket source file consists of a single module expres­sion at the top level. This is why in Racket lingo, a source file is also known as a module. For instance, these two Racket sources are roughly equiv­a­lent:

   foo.rkt

   #lang racket
   (displayln (format "Hello world ~a" 42))

   1 2	#lang racket (displayln (format "Hello world ~a" 42))

   
   foo.rkt

   (module foo racket
     (displayln (format "Hello world ~a" 42)))

   1 2	(module foo racket (displayln (format "Hello world ~a" 42)))

   
   

   Ques­tion: in what way are they not equiv­a­lent?

7. 

   The expander deter­mines the seman­tics of the new module. It does this by supplying 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.

   foo-pollen.rkt

   (module foo pollen
     (println metas))

   1 2	(module foo pollen (println metas))

   
   foo-racket.rkt

   (module foo racket
     (println metas))

   1 2	(module foo racket (println metas))

   
   

   Ques­tion: why do the modules above behave differ­ently?

8. 

   The expander leaves behind an ordi­nary Racket program (known as the fully expanded program) which can be eval­u­ated normally (by running it with racket).

9. 

   Our goal in every language imple­men­ta­tion: to use the reader and expander to convert our surface nota­tion into the equiv­a­lent Racket program. In that sense, every Racket-imple­mented language is a source-to-source compiler.

10. 

    Corol­lary: since every language ulti­mately compiles into a Racket program, your language can do anything Racket can do.

11. 

    The reader and expander do their work in sepa­rate passes. How we divide the labor between them is discre­tionary.

12. 

    A language can have multiple readers that target a single expander.

    

    Ques­tion: why might this be valu­able?

13. 

    Or multiple expanders that target a single reader.

    

    Ques­tion: why might this be valu­able?

14. 

    A language can be imple­mented using any #lang (as long as it adheres to a few neces­sary conven­tions).

    

    Ques­tion: why might this be valu­able?

hello.rkt

#lang pollen
Hello world
◊metas

1 2 3

#lang pollen Hello world ◊metas



Hello world
'#hasheq((here-path . "hello.rkt"))

1 2	Hello world '#hasheq((here-path . "hello.rkt"))



doc

1

> doc



"Hello world\n'#hasheq((here-path . \"hello.rkt\"))"

1	"Hello world\n'#hasheq((here-path . \"hello.rkt\"))"

• 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