Thank you for your comment

Beau­tiful Racket / racket school 2019

Day 1

Let’s take a closer look at the reader now (and next, the expander).

Powerful points

  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
    copy to clipboard
    #lang racket
    "Hello world"
    1
2
    #lang racket
"Hello world"
    copy to clipboard

  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
    copy to clipboard
    #lang reader (submod racket/main reader)
    "Hello world"
    1
2
    #lang reader (submod racket/main reader)
"Hello world"
    copy to clipboard

  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)
    ···))
    copy to clipboard

    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))
    ···))
    copy to clipboard

  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))))
    copy to clipboard

    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))))
    copy to clipboard

    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)))))
    copy to clipboard

    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 ...)))))
    copy to clipboard

    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))
    copy to clipboard

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

Mission

Write a language called #lang read-only that:

  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.

The result should be that any #lang read-only file eval­u­ates the same way as #lang racket:

test.rkt
#lang read-only

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

"hello world"
(+ 1 (* 2 (- 3)))
copy to clipboard

Result:

"hello world"
-5
1
2
"hello world"
-5
copy to clipboard

Hint: You only need one file, with a reader submodule:

read-only/main.rkt
#lang br
(module reader br
  ···)
1
2
3
#lang br
(module reader br
  ···)
copy to clipboard

Hint: Beyond that, start with one of the templates above.

Hint: read-expression is not a real func­tion. But read is.

Hint: You can test for eof with eof-object?. Or you can figure out how to use in-port.

Summary

First things first.

← prev next →