An experiment in partial evaluation: the generation of a compiler generator
Proc. of the first international conference on Rewriting techniques and applications
The system F of variable types, fifteen years later
Theoretical Computer Science
Two-level semantics and code generation
Theoretical Computer Science - First European Symposium on Programming, Saarbru:9Aicken, W. Germany, March 17:8
A functional theory of local names
POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Optimizing ML with run-time code generation
PLDI '96 Proceedings of the ACM SIGPLAN 1996 conference on Programming language design and implementation
Multi-stage programming with explicit annotations
PEPM '97 Proceedings of the 1997 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
An Automatic Program Generator for Multi-Level Specialization
Lisp and Symbolic Computation
Run-time code generation and modal-ML
PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
Modal types as staging specifications for run-time code generation
ACM Computing Surveys (CSUR) - Special issue: electronic supplement to the September 1998 issue
First-order modal logic
PEPM '00 Proceedings of the 2000 ACM SIGPLAN workshop on Partial evaluation and semantics-based program manipulation
A modal analysis of staged computation
Journal of the ACM (JACM)
Semantic analysis of normalisation by evaluation for typed lambda calculus
Proceedings of the 4th ACM SIGPLAN international conference on Principles and practice of declarative programming
Meta-programming with names and necessity
Proceedings of the seventh ACM SIGPLAN international conference on Functional programming
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Observable Properties of Higher Order Functions that Dynamically Create Local Names, or What's new?
MFCS '93 Proceedings of the 18th International Symposium on Mathematical Foundations of Computer Science
Nominal Logic: A First Order Theory of Names and Binding
TACS '01 Proceedings of the 4th International Symposium on Theoretical Aspects of Computer Software
Primitive Recursion for Higher-Order Abstract Syntax
TLCA '97 Proceedings of the Third International Conference on Typed Lambda Calculi and Applications
Efficient Multi-level Generating Extensions for Program Specialization
PLILPS '95 Proceedings of the 7th International Symposium on Programming Languages: Implementations, Logics and Programs
A Metalanguage for Programming with Bound Names Modulo Renaming
MPC '00 Proceedings of the 5th International Conference on Mathematics of Program Construction
A temporal-logic approach to binding-time analysis
LICS '96 Proceedings of the 11th Annual IEEE Symposium on Logic in Computer Science
Semantical Analysis of Higher-Order Abstract Syntax
LICS '99 Proceedings of the 14th Annual IEEE Symposium on Logic in Computer Science
Abstract Syntax and Variable Binding
LICS '99 Proceedings of the 14th Annual IEEE Symposium on Logic in Computer Science
Intensionality, Extensionality, and Proof Irrelevance in Modal Type Theory
LICS '01 Proceedings of the 16th Annual IEEE Symposium on Logic in Computer Science
Multistage programming: its theory and applications
Multistage programming: its theory and applications
Automating the meta theory of deductive systems
Automating the meta theory of deductive systems
Implementing multi-stage languages using ASTs, Gensym, and reflection
Proceedings of the 2nd international conference on Generative programming and component engineering
A judgmental reconstruction of modal logic
Mathematical Structures in Computer Science
Closed types for a safe imperative MetaML
Journal of Functional Programming
Journal of Functional Programming
A modal foundation for meta-variables
MERLIN '03 Proceedings of the 2003 ACM SIGPLAN workshop on Mechanized reasoning about languages with variable binding
Accomplishments and research challenges in meta-programming
SAIG'01 Proceedings of the 2nd international conference on Semantics, applications, and implementation of program generation
Fundamenta Informaticae
A polymorphic modal type system for lisp-like multi-staged languages
Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A multi-stage language with intensional analysis
Proceedings of the 5th international conference on Generative programming and component engineering
ACM Transactions on Computational Logic (TOCL)
A Logical Foundation for Environment Classifiers
TLCA '09 Proceedings of the 9th International Conference on Typed Lambda Calculi and Applications
Abstract parsing for two-staged languages with concatenation
GPCE '09 Proceedings of the eighth international conference on Generative programming and component engineering
Finally tagless, partially evaluated: Tagless staged interpreters for simpler typed languages
Journal of Functional Programming
Directly reflective meta-programming
Higher-Order and Symbolic Computation
Finally tagless, partially evaluated: tagless staged interpreters for simpler typed languages
APLAS'07 Proceedings of the 5th Asian conference on Programming languages and systems
Static analysis of multi-staged programs via unstaging translation
Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Constructive linear-time temporal logic: Proof systems and Kripke semantics
Information and Computation
Program generation and components
FMCO'04 Proceedings of the Third international conference on Formal Methods for Components and Objects
Hi-index | 0.00 |
Staging is a programming technique for dividing the computation in order to exploit the early availability of some arguments. In the early stages the program uses the available arguments to generate, at run time, the code for the late stages. A type system for staging should ensure that only well-typed expressions are generated, and that only expressions with no free variables are permitted for evaluation. In this paper, we present a calculus for staged computation in which code from the late stages is composed by splicing smaller code fragments into a larger context, possibly incurring capture of free variables. The type system ensures safety by tracking the names of free variables for each code fragment. The type system is based on the necessity operator □ from constructive modal logic, which we index with a set of names C. Our type □CA classifies expressions of type A that belong to the late stage, and whose free names are in the set C.