Transforming Functional Logic Programs into Monadic Functional Programs

Abstract

Abstract. We present a high-level transformation scheme to translate lazy functional logic programs into pure Haskell programs. This transformation is based on a recent proposal to efficiently implement lazy non-deterministic computations in Haskell into monadic style. We build on this work and define a systematic method to transform lazy functional logic programs into monadic programs with explicit sharing. This results in a transformation scheme which produces high-level and flexible target code. For instance, the target code is parametric w.r.t. the concrete evaluation monad. Thus, different monad instances could, for example, define different search strategies (e.g., depth-first, breadth-first, parallel). We formally describe the basic compilation scheme and some useful extensions.

KiCS2: A New Compiler from Curry to Haskell

“…Our benchmarks show that an efficient implementation by compiling into a functional language depends on carefully handling the sharing of non-deterministic choices. For instance, our previous implementation [13], where sharing is explicitly managed by the monadic techniques proposed in [19], has not satisfied the expectations that came from the benchmarks reported in [19]. Due to these experiences, in our new compiler we use the compilation scheme initially proposed in [12] which produces much faster code, as shown in our benchmarks.…”

“…PAKCS has been used for a number of practical applications of Curry. Another mature implementation we consider is MCC [32] (Version 0.9.10) which compiles Curry into C. MonC [13] is a compiler from Curry into Haskell. It is based on a monadic representation of non-deterministic computations where sharing is explicitly managed by the technique proposed in [19].…”

“…In the introduction we already discussed the various efforts to implement functional logic languages, like the construction of abstract machines [9,27,32] and the compilation into Prolog [5] or Haskell [13,15,16]. Our benchmarks show that an efficient implementation by compiling into a functional language depends on carefully handling the sharing of non-deterministic choices.…”

“…If one compiles into a non-strict functional language like Haskell, one can reuse the implementation of lazy evaluation and higher-order functions, but one has to implement non-deterministic evaluations [13,15]. Although Haskell offers list comprehensions to model backtracking [36], this cannot be exploited due to the specific semantical requirements of the combination of non-strict and non-deterministic operations [20].…”

Parametricity and Proving Free Theorems for Functional-Logic Languages

“…Also, and independently of its type, the local variable cannot be used within its own defining expression, which is an actual restriction compared to full Curry. 3 Logic programming features come into CuMin by certain primitives: Computations that always fail are represented by failure. In contrast to Curry, there are no explicit free variables.…”