1.14 Syntactic Sugar

1.14.1 Preface: What’s wrong with Racketish?

Exprs-lang v9 is a good start at a core language. You could start building standard libraries and get to work. But it’s missing a handful of nice features. Most languages support various complex data literals, such as literals for lists, array, or other structured data. They also support features you cannot encode as functions, like short-circuiting boolean operations and and or.

These get elaborated very early. In Racket, these are mostly implemented as macros, a user-defined function that transformer source syntax. We’ll design a compiler pass that isn’t quite a macro system, but should give you an idea of how a macro system works, and give you the ability to add new syntactic sugar to the language.

Below, we define Racketish-Surface.

We add two special syntaxes, (quote s-expr) for quoted lists, and (vector value ...) for vector literals. Note that our language does not have symbols, so our s-expr differs from Racket’s. The only thing to know is that this takes an arbitrary number of arguments.

We also add two reader notations to the surface language. ’s-expr is a reader macro in Racket and is implicitly elaborated to (quote s-expr). #(value ...) is the notation for vector literals, and is equivalent to (vector (quote value) ...), but not syntactically identical in the same way ’s-expr and (quote s-expr) are.

I can’t typeset these examples using my normal REPL typesetting feature since Racket implicitly renders them identically.

We also introduce a new form for applying macros, and add a few macros. We also make procedure calls implicit; essentially, anything that looks like an application form is either a macro application, or, is implicitly a procedure call.

1.14.2 Implementing Syntactic Sugar

Macro expansion is the first step. Ideally, this is designed to be extensible, so we can add new macros at will, or even allow the user to define macros.

Our target language is Exprs-lang v9

All macros are elaborated to existing features. We also elaborate implicit procedure call into explicit call.

These rewrites are essentially syntax-case macros, recursive pattern-based macros that can perform computation at compile time.

Notice that each macro can generate more uses of macros. As a result, the recursive structure of this elaborate pass is going to be slightly different from other passes.

procedure (expand-macros p) → exprs-lang-v9?

p : racketish-surface?

Expand all Racketish-Surface macros.

1.14.3 Appendix: Overview

This graph does not integrate the Recursive Data chapter.

Figure 11: Overview of Compiler Version 10