Set abstraction in functional and logic programming

2000

The possibility of translating logic programs into functional ones has long been a subject of investigation. Common to the many approaches is that the original logic program, in order to be translated, needs to be well-moded and this has led to the common understanding that these programs can be considered to be the "functional part" of logic programs. As a consequence of this it has become widely accepted that "complex" logical variables, the possibility of a dynamic selection rule, and general properties of non-well-moded programs are exclusive features of logic programs. This is not quite true, as some of these features are naturally found in lazy functional languages. We readdress the old question of what features are exclusive to the logic programming paradigm by defining a simple translation applicable to a wider range of logic programs, and demonstrate that the current circumscription is unreasonably restrictive.

Science of Computer Programming, 1995

In this paper we present a new programming technique for lazy functional programming languages. The technique is embedded in a programming methodology which is based on divide and conquer: the division of problems into subproblems. Such a division will be represented by a call graph.

We develop an e ective model for higher-order functional-logic programming by re ning higher-order narrowing calculi. The re nements reduce the high degree of non-determinism in narrowing calculi, utilizing properties of functional(-logic) programs. These include convergent and left-linear rewrite rules. All re nements can be combined to a narrowing strategy which generalizes call-by-need as in functional programming. Furthermore, we consider conditional rewrite rules which are often convenient for programming applications.

Theoretical Computer Science, 1989

A denotationaf semantics for the A-calculus is described. The semantics is cotinuationbased, and so reflects the order in which expressions are evaluated. It provides a means by which lazy functional languages can be better understood.

2000

We present a higher-order functional/logic language, ROSE. The programs of ROSE are made up of conditional constructor based term rewriting systems. The conditions in the rules can optionally be committing. The operational semantics of the language is conditional narrowing, augmented to deal with committing conditions. The major innovation of the language is the use of committing guards and backtracking to

Lecture Notes in Computer Science, 1995

Using higher-order functions is standard practice in functional programming, but most functional logic programming languages that have been described in the literature lack this feature. The natural way to deal with higher-order functions in the framework of ( rst-order) term rewriting is through so-called applicative term rewriting systems. In this paper we argue that existing calculi for lazy narrowing either do not apply to applicative systems or handle applicative terms very ineciently. We propose a new lazy narrowing calculus for applicative term rewriting systems and prove its completeness.

We present a high-level transformation scheme to translate lazy functional logic programs into pure Haskell programs. This transformation is based on a recent proposal to efficiently implement lazy non-deterministic computations in Haskell into monadic style. We build on this work and define a systematic method to transform lazy functional logic programs into monadic programs with explicit sharing. This results in a transformation scheme which produces high-level and flexible target code. For instance, the target code is parametric w.r.t. the concrete evaluation monad. Thus, different monad instances could, for example, define different search strategies (e.g., depth-first, breadth-first, parallel). We formally describe the basic compilation scheme and some useful extensions.

In this paper we propose a new generic scheme CF LP (D), intended as a logical and semantic framework for lazy Constraint Functional Logic Programming over a parametrically given constraint domain D. As in the case of the well known CLP (D) scheme for Constraint Logic Programming, D is assumed to provide domain specific data values and constraints. CF LP (D) programs are presented as sets of constrained rewrite rules that define the behaviour of possibly higher order and/or non-deterministic lazy functions over D. As the main novelty w.r.t. previous related work, we present a Constraint Rewriting Logic CRW L(D) which provides a declarative semantics for CF LP (D) programs. This logic relies on a new formalization of constraint domains and program interpretations, which allows a flexible combination of domain specific data values and user defined data constructors, as well as a functional view of constraints.

Proceedings of the 19th ACM SIGPLAN-SIGACT symposium on Principles of programming languages - POPL '92, 1992

Although there is considerable experience in using languages that combine the functional and logic programming paradigms, the problem of providing an adequate semantic foundation for such languages has remained open. In an earlier paper, we solved this problem for rst-order languages by reducing the problem to that of solving simultaneous xpoint equations involving closure operators over a Scott domain and showing that the resulting semantics was fully abstract with respect to the operational semantics 3]. These results showed that the rst-order fragment could be viewed as a language of incremental de nition of data structures through constraint intersection. The problem for higher-order languages remained open, in part because higher-order functions can interact with logic variables in complicated ways to give rise to behavior reminiscent of own variables in Algol-60. We solve this problem in this paper. We show that in the presence of logic variables, higher-order functions may be modeled extensionally as closure operators on function graphs ordered in a way reminiscent of the ordering on extensible records in studies of inheritance 1]. We then extend the equation solving semantics of the rst-order subset to the full language, and prove the usual soundness and adequacy theorems for this semantics. These results show that a higher-order functional language with logic variables can be viewed as a language of incremental de nition of functions.

Lecture Notes in Computer Science, 2006

Program slicing is a well-known technique that has been widely used for debugging in the context of imperative programming.