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.

We define a transformation from a left-linear constructor-based conditional rewrite system into an overlapping inductively sequential rewrite system. This transformation is sound and complete for the computations in the source system. Since there exists a sound and complete narrowing strategy for the target system, the combination of these results offers the first procedure for provably sound and complete narrowing computations for the whole class of the leftlinear constructor-based conditional rewrite systems. We address the differences between demand driven and lazy strategies and between narrowing strategies and narrowing calculi. In this context, we analyze the efficiency and practicality of using our transformation for the implementation of functional logic programming languages. The results of this paper complement, extend, and occasionally rectify, previously published results in this area. Categories and Subject Descriptors D.1.1 [Programming Techniques]: Applicative (Functional) Programming; D.1.6 [Programming Techniques]: Logic Programming; D.3.3 [Programming Languages]: Language Constructs and Features---Control structures; D.3.4 [Programming Languages ]: Processors---Optimization; F.4.2 [Mathematical Logic and Formal Languages]: Grammars and Other Rewriting Systems; I.1.1 [Algebraic Manipulation]: Expressions and Their Representation ---Simplification of expressions; I.2.2 [Automatic Programming ]: Program transformation General Terms Algorithms, Languages, Performance, Theory Keywords Functional Logic Programming Languages, Rewrite Systems, Narrowing Strategies, Call-By-Need This work has been supported in part by the National Science Foundation grant INT-9981317. 1.

Partial evaluation is a method for program specialization based on fold/unfold transformations [8, 25]. Partial evaluation of pure functional programs uses mainly static values of given data to specialize the program [15, 44]. In logic programming, the so-called static/dynamic distinction is hardly present, whereas considerations of determinacy and choice points are far more important for control [12]. We discuss these issues in the context of a (lazy) functional logic language. We formalize a two-phase specialization method for a non-strict, first order, integrated language which makes use of lazy narrowing to specialize the program w.r.t. a goal. The basic algorithm (first phase) is formalized as an instance of the framework for the partial evaluation of functional logic programs of [2, 3], using lazy narrowing. However, the results inherited by [2, 3] mainly regard the termination of the PE method, while the (strong) soundness and completeness results must be restated for the lazy strategy. A post-processing renaming scheme (second phase) is necessary which we describe and illustrate on the well-known matching example. This phase is essential also for other non-lazy narrowing strategies, like innermost narrowing, and our method can be easily extended to these strategies. We show that our method preserves the lazy narrowing semantics and that the inclusion of simplification steps in narrowing derivations can improve control during specialization.

Higher-order lazy narrowing is a general method for solving E-unification problems in theories presented as sets of rewrite rules. In this paper we study the possibility to improve the search for normalized solutions of a higher-order lazy narrowing calculus LN. We introduce a new calculus, LNff, obtained by extending LN and define an equation selection strategy Sn such that LNff with strategy Sn is complete. The main advantages of using LNff with strategy Sn instead of LN include the possibility to restrict the application of outermost narrowing at variable position, and the computation of more specific solutions because of additional inference rules for solving ex-ex equations. We also show that for orthogonal pattern rewrite systems we can adopt an eager variable elimination strategy that makes the calculus LNff with strategy Sn even more deterministic.

this paper we present a computation model for a higher-order functional and logic programming. Although investigations of computation models for higherorder functional logic languages are under way[13, 9, 8, 20, 22], implemented functional logic languages like K-LEAF[6] and Babel[18] among others, are all based on first-order models of computation. First-order narrowing has been used as basic computation mechanism. The lack of higher-order-ness is exemplified by the following prototypical program

In this paper we extend the lazy narrowing calculus of Middeldorp, Okui, and Ida [13] to conditional rewrite systems. We show that our calculus is strongly complete whenever basic conditional narrowing is complete. This generalizes one of the three main results of [13] to the conditional case. As a corollary we obtain the strong completeness for three classes of conditional rewrite systems, one of which is the class of decreasing and confluent systems. For this latter class we present a simple direct proof. 1. Introduction Narrowing (Hullot [8]) is the underlying computational mechanism of many programming languages that integrate the functional and logic programming paradigms (Hanus [5]). The desirable property of narrowing is completeness: for every solution to a given goal a more general solution can be found by narrowing. In this paper we are concerned with calculi in which narrowing is replaced by more elementary inference rules. Completeness issues for the lazy narrowing calculu...

The integration of higher-order functions into functional logic programming is widely seen as a powerful and desirable feature. The natural way to deal with higher-order functions in the well-studied framework of first-order term rewriting is through so-called applicative term rewriting systems (ATRSs). We propose a new calculus, called LNCA, to deal efficiently with confluent ATRSs and prove its soundness and completeness.

In this paper we consider the lazy conditional narrowing calculus LCNC of [4]. LCNC is the extension of lnc to conditional term rewrite systems (CTRSs for short). The extension is motivated by the observation that CTRSs are much more expressive than unconditional TRSs for describing interesting problems in natural and concise way. However, the additional expressive power raises two problems: (1) confluence is insufficient to guarantee the completeness with respect to normalized solutions, and (2) the search space increases dramatically because the conditions of the applied rewrite rule are added to the current goal. In [4] several completeness results for lcnc are presented. The only result which does not assume some kind of termination assumption does not permit extra variables in the conditions and right-hand sides of the rewrite rules. In this paper we show the completeness of LCNC with leftmost selection for the class of (confluent) deterministic oriented CTRSs. Determinism was introduced by Ganzinger [1] and has proved to be very useful for the study of the (unique) termination behavior of well-moded Horn clause programs (cf. [5]).

. This paper is concerned with the lazy conditional narrowing calculus lcnc. In an earlier paper we proved that this calculus is complete with respect to normalizable solutions for the class of conuent but not necessarily terminating conditional rewrite systems without so-called extra variables in the conditional parts of the rewrite rules. Unfortunately, the proof does not provide any useful complete selection function, hence in implementations we need to backtrack over the choice of equations in goals in order to guarantee that all solutions are enumerated. This is in contrast to the unconditional case where completeness with respect to the leftmost selection function is known. In this paper we close the gap by proving the completeness of lcnc with respect to the leftmost selection strategy for the above-mentioned class of conditional rewrite systems. 1 Introduction Narrowing (Fay [5], Hullot [16]) was originally invented as a general method for solving unication prob...

Partial evaluation is a method for program specialization based on fold/unfold transformations [4, 16]. Partial evaluation of functional programs uses only static values of given data to specialize the program. In logic programming, the so-called static/dynamic distinction is hardly present, whereas considerations of determinacy and choice points are far more important for control [8]. In this paper, we formalize a two-phase specialization method for a non-strict functional logic language which makes use of (normalizing) lazy narrowing to specialize the program w.r.t. a goal.