Functional Logic Programming with Static Determinism Analysis : Design and Implementation
Die vorliegende Arbeit befasst sich mit der Entwicklung, Implementierung und Analyse funktional logischer Programmiersprachen mit besonderem Fokus auf die Kombination von fauler Auswertung und Nichtdeterminismus. Funktional logische Sprachen verbinden funktionale und logische Paradigmen und ermöglichen dadurch eine flexible und ausdrucksstarke Programmierumgebung. Der erste Hauptbeitrag ist die Entwicklung eines monadischen Laufzeitsystems für die Programmiersprache Curry. Ein Schwerpunkt liegt auf einer effizienten Implementierung von Pull-Tabbing, einer Technik zur Handhabung von Nichtdeterminismus. Darüber hinaus betrachten wir verschiedene Erweiterungen funktional logischer Sprachen und zeigen, wie das Laufzeitsystem für deterministische Programmabschnitte optimiert werden kann. Das Ergebnis ist ein Compiler mit Laufzeitsystem, der gegenüber bestehenden Systemen messbare Verbesserungen bei der Ausführung funktional logischer Programme erzielt. Der zweite Hauptbeitrag behandelt die Prototypisierung von Programmiersprachen mittels Compiler-Plugins, insbesondere im Kontext des GHC (Glasgow Haskell Compiler). Wir zeigen, wie sich mit Compiler-Plugins prototypische Sprachimplementierungen, zum Beispiel für einen Curry-Compiler, erstellen lassen, und diskutieren die Vorteile sowie die Herausforderungen dieses Ansatzes. Der dritte Hauptbeitrag entwickelt Determinismus-Typen zur statischen Analyse funktional logischer Programme. Wir definieren ein Typsystem, das die Determinismuseigenschaften von Funktionen und Ausdrücken statisch analysierbar macht, und demonstrieren seine praktische Anwendbarkeit. Dazu führen wir eine formale Semantik ein und beweisen die Korrektheit des Ansatzes mithilfe des Beweisassistenzsystems Rocq. Auf Basis dieser Determinismusinformationen lässt sich die im ersten Beitrag entwickelte Optimierung gezielt auf geeignete Programmabschnitte anwenden, wodurch die Effizienz funktional logischer Programme weiter gesteigert wird. Zusätzlich liefert die statische Analyse Programmierenden präzisere Warnungen und hilfreiche Informationen. Ferner zeigen wir, wie die Inferenz von Determinismus-Typen realisiert werden kann, und präsentieren eine Implementierung des entsprechenden Algorithmus.
This thesis investigates the design, implementation, and analysis of functional logic programming languages with a particular focus on the combination of lazy evaluation and non-determinism. Functional logic languages combine functional and logic programming paradigms, enabling a flexible and expressive programming environment. The first main contribution is the development of a monadic run-time system for the programming language Curry. Emphasis is placed on an efficient implementation of pull-tabbing, a technique for handling non-determinism. Furthermore, we consider various extensions of functional logic languages and show how the run-time system can be optimized for deterministic program sections. The result is a compiler with a run-time system that achieves measurable improvements in executing functional logic programs compared to existing systems. The second main contribution addresses prototyping programming languages via compiler plugins, particularly in the context of the GHC (Glasgow Haskell Compiler).We demonstrate how prototypical language implementations, such as a Curry compiler, can be created using compiler plugins and discuss the advantages and challenges of this approach. The third main contribution develops determinism types for static analysis of functional logic programs. We define a type system that makes the determinism properties of functions and expressions statically analyzable and demonstrate its practical applicability. To this end, we introduce a formal semantics and prove the correctness of the approach using the Rocq theorem prover. Based on this determinism information, the optimization developed in the first contribution can be applied specifically to suitable program sections, further improving the efficiency of functional logic programs. Additionally, the static analysis provides programmers with more precise warnings and helpful information. Furthermore, we show how the inference of determinism types can be realized and present an implementation of the corresponding algorithm.
Supplementary resources
-
(Software)
GHC Language Plugins and Examples
-
(Software)
Kiel Monadic Curry Compiler
-
(Software)
Curry Frontend - Determinism Types
Preview
Rights
Use and reproduction:
Please note that individual components of the publication may be subject to other licensing or copyright conditions.