Compiling a Functional Logic Language: The Basic Scheme

Abstract

Abstract. We present the design of a compiler for a functional logic programming language and discuss the compiler's implementation. The source program is abstracted by a constructor based graph rewriting system obtained from a functional logic program after syntax desugaring, lambda lifting and similar transformations provided by a compiler's front-end. This system is non-deterministic and requires a specialized normalization strategy. The target program consists of 3 procedures that execute graph replacements originating from either rewrite or pull-tab steps. These procedures are deterministic and easy to encode in an ordinary programming language. We describe the generation of the 3 procedures, discuss the correctness of our approach, highlight some key elements of an implementation, and benchmark the performance of a proof-of-concept. Our compilation scheme is elegant and simple enough to be presented in one page.

Compiling a Functional Logic Language: The Fair Scheme

“…We will compare these two approaches in Section 7, but in short, our strategy handles failures, avoids "don't know" non-determinism, and ensures the (strong) completeness of computations. None of these properties holds for the scheme of [16].…”

“…of L that execute both the recursive calls and the replacements originating from the steps. This style of compilation for functional logic languages was pioneered in [16], where also three procedures were defined for the same purpose. We will compare these two approaches in Section 7, but in short, our strategy handles failures, avoids "don't know" non-determinism, and ensures the (strong) completeness of computations.…”

“…The notion of trace [16], recalled below, allows us to keep track of a subgraph in a graph after the graph undergoes a sequence of replacements. The definition is nontrivial, but its application in an implementation is straightforward.…”

“…The application of a rule is allowed only if no rule of higher priority is applicable. Any reference to a node in the actions of any rule is the trace [16] of the node being referenced, i.e., tracing is consistently and systematically used by every rule without explicit notation. The notation null is a visible representation of an empty sequence of expressions, actions, steps, etc.…”

“…The trace [16] of t captures the changes that t undergoes as it passes through target procedures. An implementation in which the expression being evaluated is a global, persistent datum passed to the target procedures by reference provides very efficient tracing.…”