A reduction semantics for imperative higher-order languages
Volume II: Parallel Languages on PARLE: Parallel Architectures and Languages Europe
Automatic binding time analysis for a typed &lgr;-calculus
POPL '88 Proceedings of the 15th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
LFP '90 Proceedings of the 1990 ACM conference on LISP and functional programming
Automatic autoprojection of recursive equations with global variable and abstract data types
Science of Computer Programming
Two-level functional languages
Two-level functional languages
Improving binding times without explicit CPS-conversion
LFP '92 Proceedings of the 1992 ACM conference on LISP and functional programming
POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Continuation-based partial evaluation
LFP '94 Proceedings of the 1994 ACM conference on LISP and functional programming
PEPM '00 Proceedings of the 2000 ACM SIGPLAN workshop on Partial evaluation and semantics-based program manipulation
Type-based analysis of uncaught exceptions
ACM Transactions on Programming Languages and Systems (TOPLAS)
A Hybrid Approach to Online and Offline Partial Evaluation
Higher-Order and Symbolic Computation
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
From control effects to typed continuation passing
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A Syntactic Theory of Dynamic Binding
Higher-Order and Symbolic Computation
Lambda-My-Calculus: An Algorithmic Interpretation of Classical Natural Deduction
LPAR '92 Proceedings of the International Conference on Logic Programming and Automated Reasoning
A temporal-logic approach to binding-time analysis
LICS '96 Proceedings of the 11th Annual IEEE Symposium on Logic in Computer Science
Hume: a domain-specific language for real-time embedded systems
Proceedings of the 2nd international conference on Generative programming and component engineering
Combinators for program generation
Journal of Functional Programming
Programming graphics processors functionally
Haskell '04 Proceedings of the 2004 ACM SIGPLAN workshop on Haskell
A monadic approach for avoiding code duplication when staging memoized functions
Proceedings of the 2006 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
Proceedings of the eleventh ACM SIGPLAN international conference on Functional programming
In search of a program generator to implement generic transformations for high-performance computing
Science of Computer Programming - Special issue on the first MetaOCaml workshop 2004
Closing the stage: from staged code to typed closures
PEPM '08 Proceedings of the 2008 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
Polymorphic delimited continuations
APLAS'07 Proceedings of the 5th Asian conference on Programming languages and systems
Multi-stage programming with functors and monads: Eliminating abstraction overhead from generic code
Science of Computer Programming
Invited talk: resource-aware programming
ICESS'04 Proceedings of the First international conference on Embedded Software and Systems
ICESS'04 Proceedings of the First international conference on Embedded Software and Systems
Implicitly heterogeneous multi-stage programming
GPCE'05 Proceedings of the 4th international conference on Generative Programming and Component Engineering
Type-specialized staged programming with process separation
Proceedings of the 2009 ACM SIGPLAN workshop on Generic programming
Direct implementation of shift and reset in the MinCaml compiler
Proceedings of the 2009 ACM SIGPLAN workshop on ML
Mint: Java multi-stage programming using weak separability
PLDI '10 Proceedings of the 2010 ACM SIGPLAN conference on Programming language design and implementation
Functional derivation of a virtual machine for delimited continuations
Proceedings of the 12th international ACM SIGPLAN symposium on Principles and practice of declarative programming
Lightweight modular staging: a pragmatic approach to runtime code generation and compiled DSLs
GPCE '10 Proceedings of the ninth international conference on Generative programming and component engineering
Typing control operators in the CPS hierarchy
Proceedings of the 13th international ACM SIGPLAN symposium on Principles and practices of declarative programming
Shifting the stage: Staging with delimited control
Journal of Functional Programming
Delimited control in OCaml, abstractly and concretely: system description
FLOPS'10 Proceedings of the 10th international conference on Functional and Logic Programming
Polymorphic multi-stage language with control effects
APLAS'11 Proceedings of the 9th Asian conference on Programming Languages and Systems
Lightweight modular staging: a pragmatic approach to runtime code generation and compiled DSLs
Communications of the ACM
Delimited control in OCaml, abstractly and concretely
Theoretical Computer Science
Reasoning about multi-stage programs
ESOP'12 Proceedings of the 21st European conference on Programming Languages and Systems
Staged computation with staged lexical scope
ESOP'12 Proceedings of the 21st European conference on Programming Languages and Systems
Type-specialized staged programming with process separation
Higher-Order and Symbolic Computation
Combinators for impure yet hygienic code generation
Proceedings of the ACM SIGPLAN 2014 Workshop on Partial Evaluation and Program Manipulation
Hi-index | 0.02 |
It is often hard to write programs that are efficient yet reusable. For example, an efficient implementation of Gaussian elimination should be specialized to the structure and known static properties of the input matrix. The most profitable optimizations, such as choosing the best pivoting or memoization, cannot be expected of even an advanced compiler because they are specific to the domain, but expressing these optimizations directly makes for ungainly source code. Instead, a promising and popular way to reconcile efficiency with reusability is for a domain expert to write code generators. Two pillars of this approach are types and effects. Typed multilevel languages such as MetaOCaml ensure _safety_: a well-typed code generator neither goes wrong nor generates code that goes wrong. Side effects such as state and control ease correctness: an effectful generator can resemble the textbook presentation of an algorithm, as is familiar to domain experts, yet insert let for memoization and if for bounds-checking, as is necessary for efficiency. However, adding effects blindly renders multilevel types unsound. We introduce the first two-level calculus with control effects and a sound type system. We give small-step operational semantics as well as a continuation-passing style (CPS) translation. For soundness, our calculus restricts the code generator's effects to the scope of generated binders. Even with this restriction, we can finally write efficient code generators for dynamic programming and numerical methods in direct style, like in algorithm textbooks, rather than in CPS or monadic style.