A Monadic Implementation of Functional Logic Programs

2026-04-30

AI Summary

This work addresses the challenge of efficiently combining nondeterminism with demand-driven evaluation in functional logic programming, where repeated computations commonly arise—particularly in purely functional languages that struggle to implement memoized nondeterministic branching. The paper proposes a monadic transformation–based compilation approach that introduces a unified monadic interface supporting memoization, functional pattern matching, and encapsulated search. By integrating both static and dynamic optimization strategies, this method achieves, for the first time, efficient memoized nondeterministic evaluation within a purely functional setting such as Haskell. Experimental results from a prototype implementation demonstrate superior performance compared to existing Curry compilers, confirming the feasibility and effectiveness of the proposed technique.

Abstract

Functional logic languages are a high-level approach to programming by combining the most important declarative features. They abstract from small-step operational details so that programmers can concentrate on the logical aspects of an application. This is supported by appropriate evaluation strategies. Demand-driven evaluation from functional programming is amalgamated with non-determinism from logic programming so that solutions or values are computed whenever they exist. This frees the programmer from considering the influence of an operational strategy on the success of a computation, but it is a challenge to the language implementer. A non-deterministic demand-driven strategy might duplicate unevaluated choices of an expression, which could duplicate the computational effort. In recent implementations, this problem has been tackled by adding a kind of memoization of non-deterministic choices to the expression under evaluation. Since this has been implemented in imperative target languages, it was unclear whether this could also be supported in a functional programming environment like Haskell. This paper presents a solution to this challenge by transforming functional logic programs into a monadic representation. Although this transformation is not new, we present an implementation of the monadic interface which supports memoization in non-deterministic branches. Additionally, we include more advanced features of functional logic languages, namely functional patterns and encapsulated search, in our approach. By optimizing our implementation for purely functional computations with both a static and dynamic approach, we are able to achieve a promising performance that outperforms current compilers for Curry.

Problem

• functional logic programming
• non-determinism
• memoization
• monadic implementation
• demand-driven evaluation

Innovation

• monadic implementation
• memoization
• non-determinism
• functional logic programming
• encapsulated search