This paper describes an implementation of narrowing, an essential component of implementations of modern functional logic languages. These implementations rely on narrowing, in particular on some optimal narrowing strategies, to execute functional logic programs. We translate functional logic programs into imperative (Java) programs without an intermediate abstract machine. A central idea of our approach is the explicit representation and processing of narrowing computations as data objects. This enables the implementation of operationally complete strategies (i.e., without backtracking) or techniques for search control (e.g., encapsulated search). Thanks to the use of an intermediate and portable representation of programs, our implementation is general enough to be used as a common back end for a wide variety of functional logic languages.

Functional logic overloading is a novel approach to userdefined overloading that extends Haskell’s concept of type classes in significant ways. Whereas type classes are conceptually predicates on types in standard Haskell, they are type functions in our approach. Thus, we can base type inference on the evaluation of functional logic programs. Functional logic programming provides a solid theoretical foundation for type functions and, at the same time, allows for programmable overloading resolution strategies by choosing different evaluation strategies for functional logic programs. Type inference with type functions is an instance of type inference with constrained types, where the underlying constraint system is defined by a functional logic program. We have designed a variant of Haskell which supports our approach to overloading, and implemented a prototype frontend for the language.

The functional strategy has been widely used implicitly (Haskell, Miranda, Lazy ML) and explicitly (Clean) as an efficient, intuitively easy to understand reduction strategy for term (or graph) rewriting systems. However, little is known of its formal properties since the strategy deals with priority rewriting which significantly complicates the semantics. Nevertheless, this paper shows that some formal results about the functional strategy can be produced by studying the functional strategy entirely within the standard framework of orthogonal term rewriting systems. A concept is introduced that is one of the key aspects of the efficiency of the functional strategy: transitive indexes . The corresponding class of transitive term rewriting systems is characterized. An efficient normalizing strategy is given for these rewriting systems. It is shown that the functional strategy is normalizing for the class of left-incompatible term rewriting systems. 1. Introduction An interesting commo...

In ML style pattern matching, pattern size is not constrained and ambiguous patterns are allowed. This generality leads to a clear and concise programming style but is challenging in the context of lazy evaluation. A first challenge concerns language designers: in lazy ML, the evaluation order of expressions follows actual data dependencies. That is, only the computations that are needed to produce the final result are performed. Once given a proper (that is, non-ambiguous) semantics, pattern matching should be compiled in a similar spirit: any value matching a given pattern should be recognized by performing only the minimal number of elementary tests needed to do so. This challenge was first met by A. Laville. A second challenge concerns compiler designers. As it stands, Laville's compilation algorithm cannot be incorporated in an actual lazy ML compiler for efficiency and completeness reasons. As a matter of fact, Laville's original algorithm did not fully treat the case of intege...

this paper we take a more direct approach: we compile pattern matching on overlapping patterns. We first recall the semantics of lazy pattern matching, as given by A. Laville [5]. Then, we explain our compilation technique as a source to source transformation. Given a set of patterns, several compilations are possible, we prove that they all satisfy a partial correctness

The research presented in this thesis is about the design and implementation of Naira, a parallel, parallelising compiler for a rich, purely functional programming language. The source language of the compiler is a subset of Haskell 1.2. The front end of Naira is written entirely in the Haskell subset being compiled. Naira has been successfully parallelised and it is the largest successfully parallelised Haskell program having achieved good absolute speedups on a network of SUN workstations. Having the same basic structure as other production compilers of functional languages, Naira's parallelisation technology should carry forward to other functional language compilers. The back end of Naira is written in C and generates parallel code in the C language which is envisioned to be run on distributed-memory machines. The code generator is based on a novel compilation scheme specified using a restricted form of Milner's ß-calculus which achieves asynchronous communication. We present the f...

We study the semantics of term rewriting systems with rule priorities (PRS), as introduced in [1]. Three open problems posed in that paper are solved, by giving counter examples. Moreover, a class of executable PRSs is identified. A translation of PRSs into transition system specifications (TSS) is given. This translation introduces negative premises. We prove that the translation preserves the operational semantics. Contents 1 Introduction 2 2 Term rewriting with rule priorities 3 2.1 Definition and semantics . . . . . . . . . . . . . . . . . . . . . . 3 2.2 Fixed points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 2.3 An executable class of PRSs . . . . . . . . . . . . . . . . . . . . 8 2.4 Counter examples to open questions . . . . . . . . . . . . . . . . 11 3 Transition system specifications 14 3.1 Universal negative premises in TSSs . . . . . . . . . . . . . . . . 15 3.2 Translation of PRSs into TSSs . . . . . . . . . . . . . . . . . . . 18 4 Operational semant...

We study the semantics of term rewriting systems with rule priorities (PRS), as introduced in [1]. Three open problems posed in that paper are solved, by giving counter examples. Moreover, a class of executable PRSs is identified. A translation of PRSs into transition system specifications (TSS) is given. This translation introduces negative premises. We prove that the translation preserves the operational semantics. Key words: term rewriting systems, rule priorities, structural operational semantics, transition system specification, negative premises. 1 Introduction Motivation. In [1], term rewriting with rule priorities has been introduced. A priority rewrite system (PRS) extends an ordinary term rewriting system (TRS) with a partial order on the rules. The main idea is to resolve a conflict between two rules by giving priority to the largest rule. One may hope that by ordering the rules of a non-confluent TRS, a confluent PRS can be obtained (i.e. a system in which each reduction ev...

Parallel pattern-matching (PPM) provides true commutative implementation of functions defined by cases in functional languages, because no argument is given precedence over any other. However, the requirement for concurrency (in general) to support these semantics means that current implementations incur a significant performance penalty over simple, traditional left-to-right semantics. We describe a source-level program transformation scheme that analyses a PPM definition and is often able to generate an equivalent definition that can be executed without concurrency. Where sequential implementation is not possible, the scheme is sometimes able to generate an equivalent definition that reduces the number of concurrent threads required to execute a definition. This transformation scheme promises to deliver a major improvement in the performance of PPM implementations.

We study the semantics of term rewriting systems with rule priorities (PRS), as introduced in Baeten et al. (1989). Three open problems posed in that paper are solved, by giving counter examples. Moreover, a class of executable PRSs is identified. A translation of PRSs into transition system specifications (TSS) is given. This translation introduces negative premises. We prove that the translation preserves the operational semantics. @ 1998-Elsevier Science B.V. All