Conclusions and Future Work

In this work, a general and flexible technology for loosely integrating relational and functional languages on the basis of abstract machines was developed.

We first highlight several aspects of this integration before discussing its achievements and possible enhancements:

• Relational and functional languages, when individually compilable into abstract machines (as in the case of PROLOG-like and LISP-like languages), can be integrated by extending their abstract machines by only a few, usually very simple instructions.
• The mutual access thus achieved on the abstract machine level is then used to integrate the languages on the source level. In the case of PROLOG-like relational languages (e.g. REL), the is builtin is generalized to allow functions defined in the functional language in addition to (usually builtin) arithmetical functions on its right-hand side. The functional language, if desired, can access relations either via once, retrieving only the first solution, or a bagof-like construct, retrieving all solutions.
• Deterministic predicates, for which a PROLOG computation rule foundation is developed in this work, can be detected and transformed into functions, thus improving their efficiency considerably since the overhead of unification and backtracking is avoided.

Let us mention here three major contributions of our functional-plus-logic programming on an integrated platform (FLIP):

• FLIP can be regarded as an implementation technique for relational languages (e.g. PROLOG) and relational-functional languages (e.g. RELFUN), where deterministic predicates exploit special-purpose compilation into a functional stack machine (LLAMA) loosely coupled to the language's principal abstract machine. In the case of RELFUN, the functional language LL needed for this implementation can even be regarded as a version of the functional source language component itself.
• Algorithms from existing software libraries can be combined even if specified in different paradigms without the need of re-implementation. Since the development and maintenance of software is very expensive, the loss of some declarativeness usually caused by hybrid integrations is justifiable.
• Since the seminal paper [\protect\citeauthoryearWarren et al.1977] there has been a dispute about the relative efficiencies of LISP and PROLOG: the authors gave examples where their PROLOG was as efficient as the LISPs of that time.

  In the current work we contribute to the efficiency of both language paradigms individually and in combination. While it is difficult to assert a definitive efficiency advantage for one of these paradigms, our benchmarks tend to support the view that LISP can still be made faster than PROLOG: in case of the integration of REL and LL, a factor of about 2-4 was achieved by transforming deterministic predicates into LL functions. This is mainly caused by LL being on a lower (though still declarative) level than relational languages, i.e. allowing much more operational specifications.

In the future, this integration can be improved in several directions:

• In the current implementation, the transformation of deterministic predicates into LL functions does not contain optimizations exploiting the extra-functional builtins of LL. In the future, optimizations such as transforming tail-recursions into loops or using case statements in addition to the if/let cascade (analogously to PROLOG indexing; see section 4.2.3.4) can be developed to further improve the efficiency.
• As was laid out in section 4.2.3.4, predicates automatically detected and transformed into deterministic functions have to contain quasi-final cuts and catch-all clauses. A remedy to avoid these is the introduction of type definitions and signatures (see example 4.7 on page ), as they are currently developed for RELFUN [\protect\citeauthoryearHall1995]. New algorithms, detecting determinism in the more declarative context of mode declarations together with signatures, have to be conceived: not only modes, but also types should be handled by abstract interpretation.
• Since the structure of the LLAMA is very similar to native machines, its instructions - unlike WAM instructions - can easily be compiled into native machine code. In future research it could be examined how LL and the LLAMA can be useful in the compilation of PROLOG and other relational languages into native code [\protect\citeauthoryearVan Roy1994][\protect\citeauthoryearTaylor1990].

  A possible scenario for this is illustrated in the following diagram:

  

• The loose integration, performed on the abstract machine level, is not restricted to relational and functional languages. Some research could be done to identify additional programming paradigms integratable in an analogous manner. These programming paradigms could either be declarative, like constraint logic or object-oriented programming, or rather operational, in order to access programming languages whose software libraries can be reused.