A syntactic theory of sequential state
Theoretical Computer Science
Referential transparency, definiteness and unfoldability
Acta Informatica
LFP '90 Proceedings of the 1990 ACM conference on LISP and functional programming
On the expressive power of programming languages
Proceedings of the third European symposium on programming on ESOP '90
Parameter-passing and the lambda calculus
POPL '91 Proceedings of the 18th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Assignments for applicative languages
Proceedings of the 5th ACM conference on Functional programming languages and computer architecture
Inferring the equivalence of functional programs that mutate data
Theoretical Computer Science
Revised report on the algorithm language ALGOL 60
Communications of the ACM
Making variables abstract: an equational theory for Russell
POPL '83 Proceedings of the 10th ACM SIGACT-SIGPLAN symposium on Principles of programming languages
Programming, Transforming, and Providing with Function Abstractions and Memories
ICALP '89 Proceedings of the 16th International Colloquium on Automata, Languages and Programming
The calculi of lambda-nu-cs conversion: a syntactic theory of control and state in imperative higher-order programming languages
A functional theory of local names
POPL '94 Proceedings of the 21st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
What is a purely functional language?
Journal of Functional Programming
Hi-index | 0.00 |
According to folklore, Algol is an “orthogonal” extension of a simple imperative programming language with a call-by-name functional language. The former contains assignments, branching constructs, and compound statements; the latter is based on the typed &lgr;-calculus. In an attempt to formalize the claim of “orthogonality”, we define a simple version of Algol and an extended &lgr;-calculus. The calculus includes the full &bgr;-rule and rules for the reduction of assignment statements and commands. It has the usual properties, e.g., it satisfies a Church-Rosser and Strong Normalization Theorem. In support of the claim that the imperative and functional components are orthogonal to each other, we show that the proofs of these theorems are combinations of separate Church-Rosser and Strong Normalization theorems for each sublanguage.An acclaimed consequence of Algol's orthogonal design is the idea that the evaluation of a program has two distinct phases. The first phase corresponds to an unrolling of the program according to the usual &bgr; and fixpoint reductions, which provide the formal counterpart to Algol's famous copy rule. The result of this phase is essentially an imperative program. The second phase executes the output of the first phase in the imperative fashion of a stack machine. Given our calculus, we can prove a Postponement Theorem and can thus formalize this phase separation.