Next: Approach and Results Up: Introduction Previous: Introduction


The objective of this work is a novel approach to the integration of functional and logic programming languages on the basis of abstract machines in the context of the RELFUN [\protect\citeauthoryearBoley1992] project. This integration is motivated by the following points:

  1. Both functional and logic programming are declarative paradigms, but are suitable for solving partially disjoint problem classes: logic programming is preferable for problems involving search, functional programming is preferable for deterministic symbolic computations on complex dynamic data structures.

    In real-world applications, often problems of both problem classes occur, thus solving them in a single programming paradigm requires some abuse of it. As a consequence, large programs developed in integrated functional-logic programming languages profit from the advantages both languages can offer.

  2. In addition to the development of new algorithms, reuse of existing software libraries plays an important role in practice, since software development and especially software maintenance is highly expensive. For this reason, stable software should be reused as often as possible, even if the programming language it has been developed in turns out to be suboptimal in some sense (``Never change a running system.''). It is thus desirable to permit combining already existing algorithms of which some are specified in a functional and some in a logic programming language, without having to re-implement any of them in the other paradigm.

  3. Logic programming languages usually have the disadvantage of being inefficient since unification and search are not directly supported by von Neumann architectures. Since the development of hardware directly suited for logic programming languages turned out to proceed slower than expected [\protect\citeauthoryearKurozumi1992][\protect\citeauthoryearDorochevsky et al.1991][\protect\citeauthoryearBenker et al.1989], other means for improving the efficiency of logic programs have to be developed, too. In addition to recent research in the field of native code generation for logic programs [\protect\citeauthoryearVan Roy1994][\protect\citeauthoryearTaylor1990], research dealing with the improved compilation of logic programs into abstract machines should be pursued, too.

    In the current work, the integration of logic and functional programming with abstract machines will be shown to be suitable for attacking the efficiency problem for the class of logic programs containing predicates that are only used deterministically: in this case, these deterministic predicates are transformed into functions which are then compiled into an abstract machine especially designed for the efficient execution of functional languages. By this, the overhead caused by the general search strategies - wastefully applied to deterministic predicates - can be avoided.

    The following diagram illustrates the integration of logic and functional programming on the basis of abstract machines and the transformation of deterministic predicates into the functional sublanguage:

  4. In concrete logic programming languages, it is often desirable to enhance the expressiveness by adding new features. This is usually either performed by directly extending (changing) the compiler/interpreter or by designing the language for extensibility via (usually extra-logical) programs written in the language itself.

    While the first approach is rather inflexible (i.e. expensive, error-prone, non-modular), the second is usually inefficient and often introduces performance penalties even for programs not requiring any extensions. In this work, a flexible and efficient means for extending the expressiveness of logic programs with the help of deterministic functions will be shown.

Next: Approach and Results Up: Introduction Previous: Introduction

Harold Boley & Michael Sintek (