Thank you for your comment

Beau­tiful Racket / tuto­rials

Extend a data format: jsonic

Booting the reader

When we invoke #lang jsonic, Racket will look for a "main.rkt" module within our jsonic direc­tory. Within that module, it will expect to find a reader submodule that provides our read-syntax func­tion. We’ll use require and provide to fetch this func­tion from a "reader.rkt" module that we’ll create next. For now, let’s put a "main.rkt" in the jsonic direc­tory that looks like this:

jsonic/main.rkt
#lang br/quicklang
(module reader br
  (require "reader.rkt")
  (provide read-syntax))
1
2
3
4
#lang br/quicklang
(module reader br
  (require "reader.rkt")
  (provide read-syntax))
copy to clipboard

The reader

One more time—let’s recap the role of the reader:

By conven­tion, Racket expects the name of the main reader func­tion to be read-syntax. This read-syntax func­tion must return one value: code for a mod­ule expres­sion, pack­aged as a syn­tax object. This syn­tax object must have no bind­ings.

In bf, we saw that we could make a read-syntax func­tion by relying on a tokenizer and a parser to do the heavy lifting.

We’ll do the same here. In fact, we’ll just take the read-syntax from bf and reuse it here, changing the expander name from bf/expander to jsonic/expander. Our new "reader.rkt" ends up like this:

jsonic/reader.rkt
#lang br/quicklang
(require "tokenizer.rkt" "parser.rkt")

(define (read-syntax path port)
  (define parse-tree (parse path (make-tokenizer port)))
  (define module-datum `(module jsonic-module jsonic/expander
                          ,parse-tree))
  (datum->syntax #f module-datum))
(provide read-syntax)
1
2
3
4
5
6
7
8
9
#lang br/quicklang
(require "tokenizer.rkt" "parser.rkt")

(define (read-syntax path port)
  (define parse-tree (parse path (make-tokenizer port)))
  (define module-datum `(module jsonic-module jsonic/expander
                          ,parse-tree))
  (datum->syntax #f module-datum))
(provide read-syntax)
copy to clipboard

By the way, we’re using parse-tree and module-datum as inter­me­diate values for read­ability. We could also write this func­tion more compactly like so:

jsonic/reader.rkt
#lang br/quicklang
(require "tokenizer.rkt" "parser.rkt")

(define (read-syntax path port)
  (datum->syntax #f `(module jsonic-mod jsonic/expander
                       ,(parse path (make-tokenizer port)))))
(provide read-syntax)
1
2
3
4
5
6
7
#lang br/quicklang
(require "tokenizer.rkt" "parser.rkt")

(define (read-syntax path port)
  (datum->syntax #f `(module jsonic-mod jsonic/expander
                       ,(parse path (make-tokenizer port)))))
(provide read-syntax)
copy to clipboard

Because Racket is an expres­sion-based language, it’s usually possible—and there­fore tempting—to just keep nesting lines of code inside each other. But it’s not a virtuous habit.

First, it makes the code harder to read—for others, but espe­cially for the future version of ourselves. What seems like clev­erly compact nota­tion today will just be an annoying brain-teaser next week.

Second, it doesn’t make the code faster. Before Racket runs a program, it opti­mizes the code. Most of these simple nota­tional “improve­ments” will be done auto­mat­i­cally by Racket anyhow. So we’re usually better off maxi­mizing the read­ability of our code.

Our read-syntax func­tion won’t work yet, because it relies on "tokenizer.rkt" and "parser.rkt". We’ll add those next.

← prev next →