ORBIT: an optimizing compiler for scheme
SIGPLAN '86 Proceedings of the 1986 SIGPLAN symposium on Compiler construction
Standard, storeless semantics for ALGOL-style block structure and call-by-name
Proceedings of the international conference on Mathematical foundations of programming semantics
Reification without evaluation
LFP '88 Proceedings of the 1988 ACM conference on LISP and functional programming
Partial evaluation of pattern matching in strings
Information Processing Letters
Computer Languages
Notions of computation and monads
Information and Computation
The essence of functional programming
POPL '92 Proceedings of the 19th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
No assembly required: compiling standard ML to C
ACM Letters on Programming Languages and Systems (LOPLAS)
Partial evaluation and automatic program generation
Partial evaluation and automatic program generation
The next 700 formal language descriptions
Lisp and Symbolic Computation - Special issue on continuations—part I
Lisp and Symbolic Computation - Special issue on continuations—part I
Proceedings of the fourth ACM SIGPLAN international conference on Functional programming
Structured Programming with go to Statements
ACM Computing Surveys (CSUR)
Correspondence between ALGOL 60 and Church's Lambda-notation: part I
Communications of the ACM
The next 700 programming languages
Communications of the ACM
Flow diagrams, turing machines and languages with only two formation rules
Communications of the ACM
Design of a separable transition-diagram compiler
Communications of the ACM
Recursive functions of symbolic expressions and their computation by machine, Part I
Communications of the ACM
Definitional Interpreters Revisited
Higher-Order and Symbolic Computation
Definitional Interpreters for Higher-Order Programming Languages
Higher-Order and Symbolic Computation
Comparing Control Constructs by Double-Barrelled CPS
Higher-Order and Symbolic Computation
Behavioral semantics of nonrecursive control structures
Programming Symposium, Proceedings Colloque sur la Programmation
An efficient environment allocation scheme in an interpreter for a lexically-scoped LISP
LFP '80 Proceedings of the 1980 ACM conference on LISP and functional programming
Rabbit: A Compiler for Scheme
Correctness of translations of programming languages--an algebraic approach
Correctness of translations of programming languages--an algebraic approach
The essence of rum: a theory of the intensional and extensional aspects of lisp-type computation (program transformation, closure, continuation structure, comparison-relation)
Orbit: an optimizing compiler for scheme
Orbit: an optimizing compiler for scheme
Locus Solum: From the rules of logic to the logic of rules
Mathematical Structures in Computer Science
On the static and dynamic extents of delimited continuations
Science of Computer Programming
The ruby programming language
Selective tail call elimination
SAS'03 Proceedings of the 10th international conference on Static analysis
Hi-index | 0.00 |
It is a time-honored fashion to implement a domain-specific language (DSL) by translation to a general-purpose language. Such an implementation is more portable, but an unidiomatic translation jeopardizes performance because, in practice, language implementations favor the common cases. This tension arises especially when the domain calls for complex control structures. We illustrate this tension by revisiting Landin's original correspondence between Algol and Church's lambda-notation. We translate domain-specific programs with lexically scoped jumps to JavaScript. Our translation produces the same block structure and binding structure as in the source program, à la Abdali. The target code uses a control operator in direct style, à la Landin. In fact, the control operator used is almost Landin's J--hence our title. Our translation thus complements a continuation-passing translation à la Steele. These two extreme translations require JavaScript implementations to cater either for first-class continuations, as Rhino does, or for proper tail recursion. Less extreme translations should emit more idiomatic control-flow instructions such as for , break , and throw . The present experiment leads us to conclude that translations should preserve not just the data structures and the block structure of a source program, but also its control structure. We thus identify a new class of use cases for control structures in JavaScript, namely the idiomatic translation of control structures from DSLs.