A domain-theoretic approach to functional and logic programming

Proceedings of the fourth international conference on Functional programming languages and computer architecture - FPCA '89, 1989

This paper addresses the declarative and computational issues of incorporating set abstraction into functional and logic programming languages. The main results are the following: (i) Relative set abstraction can combine a lazy higher-order functional programming with not only first-order Horn logic, but also with a useful subset of higher-order Horn logic. Sets, as well as functions, can be treated as first-class objects. (ii) Angelic powerdomains provide the semantic foundation. These are compatible with lazy evaluation and are well-defined over elements from even non-flat (higher-order) domains. (iii) A new computation rule, more efficient than the parallel-outermost rule, is developed and shown to be a correct computation rule. (A simple left-most rule is not adequate for this language.) (iv) Optimizations incorporating ideas from narrowing and resolution greatly improve the efficiency of the interpreter, while maintaining correctness.

1987

\Ve propose a new approach to the integration of functional and logic languages, based on a theory of unification and set-valued functions. A set-valued function maps a tuple of input sets into an output set. We describe a language called Setlog which illustrates this approach, and give its model-theoretic, fixed-point, and operational semantics. The model-theoretic semantics and fixed-point semantics resemble that of Horn logic. The operational semantics uses outermost reduction (for set-valued functions) and unification (for terms). '\Ve establish the correctness of the operational semantics through soundness and completeness proofs. ._. .. t This research is sup"porte•d by a grant DCR-'8603609 froin the Na-tiOiial Science Faun~ dation and. contract

1989

This dissertation addresses the problem of incorporating into lazy higher-order functional programming the relational programming capability of Horn logic. The language design is based on set abstraction, a feature whose denotational semantics has until now not been rigorously defined. A novel approach is taken in constructing an operational semantics directly from the denotational description. The main results of this dissertation are: (i) Relative set abstraction can combine lazy higher-order functional programming with not only first-order Horn logic, but also with a useful subset of higherorder Horn logic. Sets, as well as functions, can be treated as first-class objects. (ii) Angelic powerdomains provide the semantic foundation for relative set abstraction. (iii) The computation rule appropriate for this language is a modified paralleloutermost, rather than the more familiar left-most rule. (iv) Optimizations incorporating ideas from narrowing and resolution greatly improve the...

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.

Lecture Notes in Computer Science, 1987

ever, existing approaches treat sets as lists for the sake of efficiency~ and thereby sacrifice a simple declarative semantics. In this paper, we present a novel language based on sets and equations, where sets are treated as sets, consistent with their semantics. The language is called SEL, for Set-Equation Language. Equations are assumed to define a confluent rewriting system when oriented left to right. Sets are defined in terms of their subsets; these rules define a nonconfiuent rewriting system when oriented left to right. We show examples of programs in this language, and provide an operational Semantics for such programs. Programs are executed by innermost reduction, which may be nondeterministic or deterministic. Nondeterministic reduction is used when one of the elements of a set is desired. Deterministic reduction is used to simplify a term via an equation or to obtain all the elements of a set. The correctness of the operational semantics is also established.

1995

2001

Theory and Practice of Logic Programming, 2007

In this paper, we present our proposal to Constraint Functional Logic Programming over Finite Domains (CFLP($\fd$)) with a lazy functional logic programming language which seamlessly embodies finite domain ($\fd$) constraints. This proposal increases the expressiveness and power of constraint logic programming over finite domains (CLP($\fd$)) by combining functional and relational notation, curried expressions, higher-order functions, patterns, partial applications, non-determinism, lazy evaluation, logical variables, types, domain variables, constraint composition, and finite domain constraints. We describe the syntax of the language, its type discipline, and its declarative and operational semantics. We also describe \toy(fd)$, an implementation for CFLP($\fd$), and a comparison of our approach with respect to CLP($\fd$) from a programming point of view, showing the new features we introduce. And, finally, we show a performance analysis which demonstrates that our implementation i...

2007

The integration of functional and logic programming is a well developed field of research. We discuss that the integration could be improved significantly in two separate aspects: sharing computations across non-deterministic branching and the declarative encapsulation of logic search. We then present a formal approach which shows how these improvements can be realized and prove the soundness of our approach.

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.