. Rewriting is a computational paradigm that specifies the actions, but not the control. We introduce a hierarchical structure representing, at a high level of abstraction, a form of control. Its application solves a specific problem arising in the design and implementation of inherently sequential, lazy, functional programming languages based on rewriting. For example, we show how to extend the expressive power of Log(F ) and how to improve the efficiency of an implementation of BABEL. Our framework provides a notion of degree of parallelism of an operation and shows that the elements of a necessary set of redexes are related by an and-or relation. Both concepts find application in parallel implementations of rewriting. In an environment in which computations can be executed in parallel we are able to detect sequential computations in order to minimize overheads and/or optimize execution. Conversely, we are able to detect when inherently sequential computations can be executed in para...

Orthogonal term rewriting systems (also known as regular systems) provide an elegant framework for programming in equational logic. O'Donnell showed that the parallel-outermost strategy, which replaces all outermost redexes in each step, is complete for such systems. Many of the reductions performed by this strategy could be wasteful in general. A lazy normalization algorithm that completely eliminated these wasteful reductions by reducing only "needed redexes" was later developed by Huet and Levy. However, this algorithm required the input programs to be restricted to the subclass of strongly sequential systems. This is because needed redexes do not exist for all orthogonal programs, and even when they do, they may not be computable. It is therefore quite natural to ask whether it is possible to devise a complete normalization algorithm for the entire class that minimizes (rather than eliminate) the wasteful reductions. In this paper we propose a solution to this problem using the concept of a necessary set of redexes. In such a set, at least one of the redexes must be reduced to normalize a term. We devise an algorithm to compute a necessary set for any term not in normal form and show that a strategy that repeatedly reduces all redexes in such a set is complete for orthogonal programs. We also show that our algorithm is "optimal" among all normalization algorithms that are based on left-hand sides alone. This means that our algorithm is lazy (like Huet-Levy's) on strongly sequential parts of a program and "relaxes laziness minimally" to handle the other parts and thus does not sacrifice generality for the sake of efficiency.

We describe a technique enabling a logic program to perform lazy rewriting. Our technique is based on a transformation of a rewrite system in a set of Horn clauses. We characterize syntactically, in terms of a hierarchical structure of the rewrite rules of an operation, the systems accepted by our transformation and outline a design technique yielding systems with these characteristics. We define our transformation, prove its correctness and other properties, and relate the efficiency of resolution to that of rewriting. Improvements over previous similar results include using a more expressive and more powerful language, generating a more efficient logic program, providing efficient operational completeness, and establishing a tight bound on the length of a resolution as a function of the length of a corresponding reduction sequence. We compare our approach with several related proposals and discuss examples which also show the integration of lazy with eager evaluation and ...

Huet and Levy pioneered lazy sequential evaluation of equational programs based on the concepts of strong-sequentiality and needed redexes. Natural extensions of their strategy are not well-suited for parallel evaluation since they do not support independent searches for needed redexes along different paths in the input term. Furthermore, the size of compiled code can be exponential in program size. We therefore propose a different notion of sequentiality called path-sequentiality that overcomes these drawbacks and thus provides a natural framework for lazy parallel evaluation. We present a sound and complete algorithm for lazy parallel normalization of path-sequential systems. We show that our algorithm is optimal in the sense that its time complexity is bounded only by the time required to perform the needed reductions. The results presented in this paper are applicable to functional languages as well through the transformation of Laville.

This report describes the design and implementation of HASKELL system. The areas implemented are the lexical analysis, parsing, intepretation of the lambda tree, and machine code generation. Because of the size, complexity and novelty of the language many of these areas present particular difficulty. A considarable amount of meta-programming was used in order to tackle the size of the project. Contents Introduction v 1 Lexical Analysis 1 1.1 Technical Overview 1 1.2 General Description 3 1.3 The Layout Rule 4 1.4 Alternative Design 5 1.5 Coding for Speed 6 1.5.1 Token Recognition 7 1.5.2 Character Copying 8 1.5.3 Memory Allocation 9 1.5.4 Symbol Table Updates 9 1.5.5 The Ultimate Combination 9 1.5.6 Performance 10 1.6 Testing 10 2 Parsing 11 2.1 Technical Overview 11 2.2 General Description 12 2.3 Handling the Grammar Ambiguities 13 2.3.1 Definable Operators and Function Applications 13 2.3.2 General 15 2.3.3 September Version 15 2.3.4 April Grammar changes 17 2.3.5 April Version 18 ...

In 1975 I started a small project to explore the consequences of implementing equational programs with no semantic compromises. Latest results include a compiler that executes exactly the logical consequences of an equational program, with run-time speed comparable to compiled Franz LISP. This paper surveys the development of the project, through theoretical foundations, algorithm development, design and implementation, application, and directions for the future. 1 Introduction This paper surveys a small project aimed at providing a style of logic programming based on equational logic. The project was always intended as an exploration of radical possibilities in programming languages, rather than as an attempt to support any particular application. Christoph Hoffmann was an equal collaborator from 1977 to 1983. Paul Chew and Robert Strandh made significant contributions in their doctoral dissertations, and Paul Golick This work was supported by NSF grant DCR-8601843. This paper was...

In 1975 I started a small project to explore the consequences of implementing equational programs with no semantic compromises. Latest results include a compiler that executes exactly the logical consequences of an equational program, with run-time speed comparable to compiled Franz LISP. This paper describes the accomplishments of the project very briefly, concentrating on shortcomings and directions for future work. 1 Introduction The most common approach to providing semantics for programming languages is to regard a program as the definition of a collection of functions. In some cases great ingenuity is required to construct the unique function associated with each symbol in a program. Inputs and outputs are regarded as values in the domains of the defined functions, and the input/output behavior of the implementation of a program is expected to be exactly the function associated with some designated symbol in the program. I prefer, This work was supported by NSF grant DCR-8601...

Strongly sequential systems, developed by Huet and Levy [HL79], has formed the basis of equational programming languages. Experience with such languages so far suggests that even complex equational programs are based only on strongly sequential systems with constructors.

Elements from the technical works