Questions: Multi-Stage Programming and Staged Compilation

Question 1

What is the key advantage of multi-stage programming over traditional metaprogramming approaches like C macros or eval()?

• A. Multi-stage programs run faster at runtime because all code generation happens before execution begins
• B. The type system guarantees that generated code is well-typed at stage 1, before it is ever executed — type errors in generated code are caught at compile time
• C. Multi-stage programming can generate code that macros cannot express, enabling more complex transformations
• D. Staging requires fewer lines of code than macro-based approaches, improving maintainability

Answer: (B)

Type safety across stages is the defining advantage. With C macros or string-based eval(), generated code is not checked until it runs — a type error in generated code only surfaces as a runtime failure. In a well-designed multi-stage language like MetaOCaml, the stage-1 type checker verifies that bracketed code (.<e>.) is well-typed even before it is executed. This means you cannot accidentally produce type-incorrect code at stage 2. Speed may also improve, but that is a consequence of specialization — not the fundamental property that distinguishes multi-stage programming.

Question 2

A programmer writes a multi-stage expression: .<fun x -> x + .~(some_int_computation)>. If some_int_computation produces a string instead of an integer at stage 1, when is the error detected?

• A. At stage 2, when the bracketed code is finally executed and the type mismatch causes a runtime failure
• B. Never — the type error is silently coerced to match the expected type
• C. At stage 1, when the type checker validates the bracketed expression and finds that splicing a string into integer addition is ill-typed
• D. Only if the programmer explicitly adds type annotations to the bracket expression

Answer: (C)

This illustrates the core value proposition of multi-stage typing. The bracket construct .<e>. does not defer type checking — it defers evaluation. The type checker inspects the bracketed expression at stage 1 and propagates types through the splice (.~) to detect mismatches. Contrast this with eval() in Python or JavaScript, where a dynamically constructed string of code is only type-checked (if at all) when it runs. The guarantee is: if stage-1 compilation succeeds, stage-2 execution will not encounter type errors from the generated code.

Question 3

C++ template instantiation is a limited form of multi-stage programming where type parameters are resolved at compile time to produce specialized code.

• T. True
• F. False

Answer: True

This analogy is accurate. In C++ templates, stage 1 is compilation — the compiler resolves template parameters and instantiates specialized versions of functions or classes. Stage 2 is execution of the specialized code. The 'multi-stage' nature is constrained: C++ templates operate only on types and compile-time constants, not arbitrary code generation with the full expressiveness of languages like MetaOCaml. But the structure — generate specialized code at one stage, execute it at another — is the same principle. Partial evaluation and compiler generators (like Yacc) are similarly understood as two-stage systems.

Question 4

Multi-stage programming and C macros provide equivalent safety guarantees because both generate code before runtime, so errors are generally caught before the program executes.

• T. True
• F. False

Answer: False

C macros are purely textual substitution with no type awareness — the preprocessor replaces tokens without understanding their types, and the resulting code is only type-checked after substitution. A type error in a macro-generated expression surfaces during compilation of the expanded output, but complex macros can generate code that type-checks incorrectly or has subtle semantic errors that are hard to diagnose. Multi-stage programming explicitly type-checks generated code at the stage where it is constructed, providing a formal guarantee that the code product is well-typed. The safety guarantee is categorically stronger.

Question 5

What are brackets and escapes in multi-stage programming, and why is type safety across stages the critical property in practice?

Model answer: Brackets (.<e>.) delay evaluation of e to a later stage — e is treated as code-as-data rather than executed immediately. Escapes (.~e) splice a current-stage value into bracketed (delayed) code. Together they let programmers explicitly control when computation happens. Type safety across stages means the type checker verifies the bracketed code is well-typed at stage 1, before stage 2 executes it — so code generation errors are caught early, not at runtime.

In practice, the value of staging is generating specialized, efficient code (e.g., a partially evaluated interpreter) without losing correctness guarantees. If type errors in generated code could only be caught at stage-2 runtime, staging would offer the same debugging experience as eval() — errors appear late, in code that is hard to inspect. The compile-time guarantee transforms code generation from a debugging nightmare into a safe, composable programming technique.