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

. Many Prolog systems offer the facility of calling external functions written in non-logic programming languages. A basic requirement is often that the arguments of the functions must be ground at invocation time, otherwise an error is reported, or the call is delayed until the arguments are sufficiently instantiated. The drawback of the latter method is twofold: (1) the arguments might never be instantiated, and (2) the dynamic checks made by the delaying mechanism are expensive. This paper presents a method, which for a given program identifies a class of atomic goals for which (1) will not occur. Moreover, we describe a method for transforming a program into an equivalent program, for which dynamic delays are avoided. 1 Introduction In many Prolog systems, pure logic programs are enriched with mechanisms for invocation of built-in arithmetic and procedures written in non-logic programming languages (like C). This is very useful, or even necessary, for writing realistic ...

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 effects of head unification with the formal parameters ¯ x, given the abstract substitution ff describing the actual parameters, so as to obtain an initial abstract environment A 1 . 2. Let the abstract environment at the program point immediately before the literal q i (¯u i ) be denoted by A i , 1 i n. For i := 1 to n do: A 0 i := analyse call(q i ; A i ); A i+1 := extend abs env (A i ; A 0 i ); 3. Compute and return the abstract environment An+1 projected on the arguments in the head of the clause. A call to a procedure is analyzed by processing each clause for that procedure, in turn, as described above. For each clause, the analysis yields an abstract environment, and these can be "summarized"---for example, using the join operator t on ASub---to yield an abstract environment describing the substitutions that may be obtained when that call returns. In the following sections, we describe how the underlying analysis described above can be extended to detect situations ...

Solving nonlinear constraints over real numbers is a complex problem. Hence constraint logic programming languages like CLP(R) or Prolog III solve only linear constraints and delay nonlinear constraints until they become linear. This efficient implementation method has the disadvantage that sometimes computed answers are unsatisfiable or infinite loops occur due to the unsatisfiability of delayed nonlinear constraints. These problems could be solved by using a more powerful constraint solver which can deal with nonlinear constraints like in RISC-CLP(Real). Since such powerful constraint solvers are not very efficient, we propose a compromise between these two extremes. We characterize a class of CLP(R) programs for which all delayed nonlinear constraints become linear at run time. Programs belonging to this class can be safely executed with the efficient CLP(R) method while the remaining programs need a more powerful constraint solver. 1 Introduction The constraint logic programming ...

. In several functional logic programming languages, functional expressions must be evaluated before unification with another term, but this can only be done if the functional expression is ground. If the functional expression is non-ground, then unification must be delayed until all the arguments have become instantiated to ground terms. If the delaying mechanism uses dynamic tests, the program will be unnecessarily inefficient. We present an analysis method for statically determining at what point in the program a given functional expression can be evaluated. This analysis is then used for transforming a functional logic program into an equivalent program, in which most dynamic delays are avoided. We show that this transformation can lead to considerable improvements in performance, compared to a dynamic delaying strategy. 1 Introduction During the last decade, an immense amount of research has been done on combining logic programming with functional and equational languages. The d...

The first logic programming languages, such as Prolog, used a fixed left-to-right atom scheduling rule. Recent logic programming languages, however, usually provide more flexible scheduling in which computation generally proceeds left-to-right but in which some calls are dynamically "delayed" until their arguments are sufficiently instantiated to allow the call to run efficiently. Such languages include constraint logic programming languages in which constraints which are "too hard" are delayed and concurrent constraint languages in which delay on shared variables is used to provide asynchronous communication between processes. We give a new framework for the global analysis of logic programming languages with dynamic scheduling which is based on approximating the delayed atoms by a closure operator. We give an example analysis for groundness based on this framework, and give the results of an implementation which demonstrates the method is practical. 1 Introduction The first logic pr...

Abstract. Functional logic languages amalgamate functional and logic programming paradigms. They can be efficiently implemented by extending techniques known from logic programming. Such implementations can be largely improved if information about the run-time behavior, in particular the modes of function calls, is available at compile time. In this paper we present a framework to derive such global information. The concrete operational semantics considered in this paper is normalizing innermost narrowing, which combines the deterministic reduction principle of functional languages with the nondeterministic search principle of logic languages. Due to the normalization process between narrowing steps, standard analysis frameworks for logic programming cannot be applied. Therefore we develop new techniques to correctly approximate the effect of the intermediate normalization process. 1 Introduction A lot of proposals have been made to amalgamate functional and logic programming languages (see [15] for a recent survey). Functional logic languages with a sound and complete operational semantics are based on narrowing (e.g., [9, 11, 25, 27]), a combination of the reduction principle of functional languages and the resolution principle of logic languages. Narrowing solves equations by finding appropriate values for variables occurring in goal equations. This is done by unifying an input term with the left-hand side of some rule and then replacing the instantiated input term by the instantiated right-hand side of the rule. Example 1. The following rules define the addition of two natural numbers which are represented by terms built from 0 and s:

. Functional logic languages amalgamate functional and logic programming paradigms. They can be efficiently implemented by extending techniques known from logic programming. In this paper we show how global information about the call modes of functions can be used to optimize the compilation of functional logic programs. Since mode information has been successfully used to improve the implementation of pure logic programs and these techniques can be applied to implementations of functional logic programs as well, we concentrate on optimizations which are unique to the operational semantics of functional logic programs. We define a suitable notion of modes for functional logic programs and present compile-time techniques to optimize the normalization process during the execution of functional logic programs. 1 Introduction In recent years, a lot of proposals have been made to amalgamate functional and logic programming languages [7, 17]. Functional logic languages with a so...

this paper we try to bridge the gap between the two formalisms by showing how concurrent logic languages can be implemented using graph rewriting. In particular, we develop techniques for mapping a wide class of CLLs including Parlog, GHC, Strand, Janus and a restricted subset of the Concurrent Prolog family onto Dactl, a compiler target language based on graph rewriting. We discuss the problems found in the process and the adopted solutions. The paper contributes to related research by: # examining the potential of graph reduction as a suitable model for implementing CLLs in terms of expressiveness and efficiency