ORBIT: an optimizing compiler for scheme
SIGPLAN '86 Proceedings of the 1986 SIGPLAN symposium on Compiler construction
Safety consideration for storage allocation optimizations
PLDI '88 Proceedings of the ACM SIGPLAN 1988 conference on Programming Language design and Implementation
Introduction to algorithms
Efficient stack allocation for tail-recursive languages
LFP '90 Proceedings of the 1990 ACM conference on LISP and functional programming
MacScheme: manual and software
MacScheme: manual and software
Semantics with applications: a formal introduction
Semantics with applications: a formal introduction
Compiling with continuations
Space efficient conservative garbage collection
PLDI '93 Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation
The essence of compiling with continuations
PLDI '93 Proceedings of the ACM SIGPLAN 1993 conference on Programming language design and implementation
Lambda, the ultimate label or a simple optimizing compiler for Scheme
LFP '94 Proceedings of the 1994 ACM conference on LISP and functional programming
Implementation of the typed call-by-value λ-calculus using a stack of regions
POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Better static memory management: improving region-based analysis of higher-order languages
PLDI '95 Proceedings of the ACM SIGPLAN 1995 conference on Programming language design and implementation
VLISP: a verified implementation of Scheme
Lisp and Symbolic Computation
CONS should not CONS its arguments, part II: Cheney on the M.T.A.
ACM SIGPLAN Notices
Abstract models of memory management
FPCA '95 Proceedings of the seventh international conference on Functional programming languages and computer architecture
Storage use analysis and its applications
Proceedings of the first ACM SIGPLAN international conference on Functional programming
Lisp in small pieces
The art of computer programming, volume 1 (3rd ed.): fundamental algorithms
The art of computer programming, volume 1 (3rd ed.): fundamental algorithms
Semantics of memory management for polymorphic languages
Higher order operational techniques in semantics
Continuation-Based Program Transformation Strategies
Journal of the ACM (JACM)
ACM SIGPLAN Lisp Pointers
IEEE Std 1178-1990, IEEE Standard for the Scheme Programming Language
IEEE Std 1178-1990, IEEE Standard for the Scheme Programming Language
A Retargetable C Compiler: Design and Implementation
A Retargetable C Compiler: Design and Implementation
The scheme 311 compiler an exercise in denotational semantics
LFP '84 Proceedings of the 1984 ACM Symposium on LISP and functional programming
Proceedings of ACM conference on Proving assertions about programs
ACM '77 Proceedings of the 1977 annual conference
An Interpreter for Extended Lambda Calculus
An Interpreter for Extended Lambda Calculus
Lambda: The Ultimate Imperative
Lambda: The Ultimate Imperative
LAMBDA: The Ultimate Declarative
LAMBDA: The Ultimate Declarative
The Art of the Interpreter or, The Modularity Complex (Parts Zero, One, and Two)
The Art of the Interpreter or, The Modularity Complex (Parts Zero, One, and Two)
Rabbit: A Compiler for Scheme
Analysis-based program transformations
ACM SIGSOFT Software Engineering Notes
Efficient and safe-for-space closure conversion
ACM Transactions on Programming Languages and Systems (TOPLAS)
A model for comparing the space usage of lazy evaluators
Proceedings of the 2nd ACM SIGPLAN international conference on Principles and practice of declarative programming
Bounding space usage of conservative garbage collectors
POPL '02 Proceedings of the 29th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Possibilities and limitations of call-by-need space improvement
Proceedings of the sixth ACM SIGPLAN international conference on Functional programming
Accurate garbage collection in an uncooperative environment
Proceedings of the 3rd international symposium on Memory management
Contracts for higher-order functions
Proceedings of the seventh ACM SIGPLAN international conference on Functional programming
The Tail-Recursive SECD Machine
Journal of Automated Reasoning
Revised Report on the Algorithmic Language Scheme
Higher-Order and Symbolic Computation
Safe-for-Space Threads in Standard ML
Higher-Order and Symbolic Computation
Implementation Strategies for First-Class Continuations
Higher-Order and Symbolic Computation
From Macros to Reusable Generative Programming
GCSE '99 Proceedings of the First International Symposium on Generative and Component-Based Software Engineering
A First-Order One-Pass CPS Transformation
FoSSaCS '02 Proceedings of the 5th International Conference on Foundations of Software Science and Computation Structures
A first-order one-pass CPS transformation
Theoretical Computer Science
Bee: an integrated development environment for the Scheme programming language
Journal of Functional Programming
Space efficient conservative garbage collection
ACM SIGPLAN Notices - Best of PLDI 1979-1999
Automatically Restructuring Programs for the Web
Automated Software Engineering
A tail-recursive machine with stack inspection
ACM Transactions on Programming Languages and Systems (TOPLAS)
EDUCATIONAL PEARL: Automata via macros
Journal of Functional Programming
Modular verification of assembly code with stack-based control abstractions
Proceedings of the 2006 ACM SIGPLAN conference on Programming language design and implementation
Slideshow: functional presentations
Journal of Functional Programming
Theoretical Computer Science - Applied semantics: Selected topics
A syntactic correspondence between context-sensitive calculi and abstract machines
Theoretical Computer Science
Creating a portable programming language using open source software
ATEC '04 Proceedings of the annual conference on USENIX Annual Technical Conference
Stack virtualization for source level debugging
Software—Practice & Experience
Recursive function data allocation to scratch-pad memory
CASES '07 Proceedings of the 2007 international conference on Compilers, architecture, and synthesis for embedded systems
Plugging a Space Leak with an Arrow
Electronic Notes in Theoretical Computer Science (ENTCS)
A static simulation of dynamic delimited control
Higher-Order and Symbolic Computation
An operational semantics for scheme1
Journal of Functional Programming
Celebrating the 50th Anniversary of Lisp
Precise garbage collection for C
Proceedings of the 2009 international symposium on Memory management
Control-flow analysis of function calls and returns by abstract interpretation
Proceedings of the 14th ACM SIGPLAN international conference on Functional programming
Revised6 report on the algorithmic language scheme
Journal of Functional Programming
Selective tail call elimination
SAS'03 Proceedings of the 10th international conference on Static analysis
A tail-recursive semantics for stack inspections
ESOP'03 Proceedings of the 12th European conference on Programming
Semantics and algebraic specification
Managing continuations for proper tail recursion
Proceedings of the 2010 international conference on Lisp
Revisiting information hiding: reflections on classical and nonclassical modularity
Proceedings of the 25th European conference on Object-oriented programming
Rethinking Java call stack design for tiny embedded devices
Proceedings of the 13th ACM SIGPLAN/SIGBED International Conference on Languages, Compilers, Tools and Theory for Embedded Systems
ICFP 2002: Contracts for higher-order functions
ACM SIGPLAN Notices - Supplemental issue
Hi-index | 0.00 |
The IEEE/ANSI standard for Scheme requires implementations to be properly tail recursive. This ensures that portable code can rely upon the space efficiency of continuation-passing style and other idioms. On its face, proper tail recursion concerns the efficiency of procedure calls that occur within a tail context. When examined closely, proper tail recursion also depends upon the fact that garbage collection can be asymptotically more space-efficient than Algol-like stack allocation.Proper tail recursion is not the same as ad hoc tail call optimization in stack-based languages. Proper tail recursion often precludes stack allocation of variables, but yields a well-defined asymptotic space complexity that can be relied upon by portable programs.This paper offers a formal and implementation-independent definition of proper tail recursion for Scheme. It also shows how an entire family of reference implementations can be used to characterize related safe-for-space properties, and proves the asymptotic inequalities that hold between them.