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:
- 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.
- 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.
- 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:
- 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.
