Constraint Logic Programming (CLP) is a merger of two declarative paradigms: constraint solving and logic programming. Although a relatively new field, CLP has progressed in several quite different directions. In particular, the early fundamental concepts have been adapted to better serve in different areas of applications. In this survey of CLP, a primary goal is to give a systematic description of the major trends in terms of common fundamental concepts. The three main parts cover the theory, implementation issues, and programming for applications.

Functional and logic programming are the most important declarative programming paradigms, and interest in combining them has grown over the last decade. Early research concentrated on the definition and improvement of execution principles for such integrated languages, while more recently efficient implementations of these execution principles have been developed so that these languages became relevant for practical applications. In this paper we survey the development of the operational semantics as well as

The distinctive merit of the declarative reading of logic programs is the validity ofallthelaws of reasoning supplied by the predicate calculus with equality. Surprisingly many of these laws are still valid for the procedural reading � they can therefore be used safely for algebraic manipulation, program transformation and optimisation of executable logic programs. This paper lists a number of common laws, and proves their validity for the standard (depth- rst search) procedural reading of Prolog. They also hold for alternative search strategies, e.g. breadth- rst search. Our proofs of the laws are based on the standard algebra of functional programming, after the strategies have been given a rather simple implementation in Haskell. 1

. We present a declarative language -- CFLP (R) -- which enhances functional logic programming with constraint solving capabilities. CFLP (R) features: polymorphic types, nondeterministic functions, lazy evaluation, higher order (even logic) computations, arithmetical constraints over real numbers and disequality constraints over syntactic terms. The features of the language are shown by means of examples, attempting to demonstrate the interest of CFLP (R). The execution mechanism of the language results of a simple combination of lazy narrowing (with a sophisticated strategy, as realized in up to date functional logic languages) and constraint solving. The language has been implemented by means of translation of source programs into a Prolog system supporting real constraint solving. This shows the practicability of the proposal. 1 Introduction Constraints play a central role in present days research, development and application of logic programming (LP) languages (see [15] for a sur...

Expressiveness of constraint programming permits solving elegantly and efficiently many problems but makes difficult for the programmer to debug and understand the behaviour of his programs since most of the solving process (addition of new constraints and propagation of variables’ domains modifications) is concealed by constraint solvers. However, tackling this problem by displaying a graphical representation of the original set of added constraints (store) is useless due to its huge size and its lack of structure whatsoever. We present in this chapter a means to organize hierarchically the store in order to divide it into manageable parts while preserving computation correctness; soundness of the method is shown, an algorithm supporting it is given, and an implemented prototype exhibiting its effectiveness is described. 1

We present a declarative language CFLP (R) which integrates lazy functional programming, logic programming and constraint solving over real numbers. Both a (higher order, polymorphic, lazy) functional language and (pure) CLP (R) can be isolated as subsets of our language. The execution mechanism of the language consists of a combination of lazy narrowing and constraint solving. As a very simple method for implementing the language, we propose a translation of CFLP (R)-programs into a logic programming language supporting real arithmetic constraint solving. This shows the practicability of the proposal.

A calculus which extends the untyped λ-calculus by constraints is presented. The constraints can be used for two purposes: in a passive way for restricting the range of variables and in an active way for computing solutions of goals. Rules for the constrained λ-calculus are presented and a complete proof of the weak Church Rosser property is given.

C.A.R. Hoare's Unified Theory of Programming gives a single framework for describing the algebraic semantics of different programming paradigms. The work presented in this thesis is aimed towards incorporating the lacking parts of logic programming paradigm into this Unified Theory. As a first step in my algebraic study of logic programming, I propose a shallow embedding of logic programs into Gofer programs. This embedding translates each Prolog predicate into a Gofer function such that both the declarative and the procedural reading of the Prolog predicate are preserved. In the standard approach to mapping logic programs to functional ones the declarative reading is lost. The shallow embedding computes by means of operations on lazy lists. The state of each step in computation is passed on as a list of substitutions, and all the implicit logic operators in Prolog are replaced by explicit Gofer operators on lists. I express a set of algebraic laws for these operators and discuss how...

Abstract not found