The Catala compiler

Architecture

The architecture of the Catala compiler is inspired by CompCert or the Nanopass framework, and is structured around many intermediate representations connected by successive translations passes.

Here is the recap picture of the different intermediate representations of the Catala compiler (made with an ASCII diagram tool):

                                     +---------------+
                                     |               |
                                     |  Surface AST  |
                                     |               |
                                     +---------------+
                                             |
                                             |
         * Separate code from legislation    |
         * Remove syntactic sugars           |
                                             v
                                     +---------------+
                                     |               |
                                     | Desugared AST |
                                     |               |
                                     +---------------+
                                             |
                                             |
 * Build rule trees for each definition      |
 * Order variable computations inside scope  |
                                             v
                                  +--------------------+
                                  |                    |
                                  | Scope language AST |
                                  |                    |
                                  +--------------------+
                                             |
                                             |
        * Convert scopes into functions      |
        * Thunking of subscope arguments     |
                                             |
                                             v
                                 +----------------------+
                                 |                      |
                                 | Default calculus AST |
                                 |                      |
                                 +----------------------+
                                             |
                                             |
                                             |
       * Compile the default term            |
                                             |
                                             v
                                 +----------------------+
                                 |                      |
                                 | Lambda calculus AST  |
                                 |                      |
                                 +----------------------+

List of top-level modules

Each of those intermediate representation is bundled into its own `dune` bundle module. Click on the items below if you want to dive straight into the signatures.

• Surface
• Desugared
• Scopelang
• Dcalc
• Lcalc

More documentation can be found on each intermediate representations here.

• The surface representation
• The desugared representation
• The scope language
• The default calculus
• The lambda calculus

The main compilation chain is defined in:

• Driver

Last, two more modules contain additional features for the compiler:

• Literate programming
• Compiler utilities