Funktional-logische Programmierung in Maude

Transkript

1 Arbeitsgruppe Programmiersprachen und Übersetzerkonstruktion Institut für Informatik Christian-Albrechts-Universität zu Kiel Betreuer: Prof. Dr. Michael Hanus Seminararbeit Funktional-logische Programmierung in Maude Jasper Paul Sikorra Wintersemester 2015/2016

2 Inhaltsverzeichnis 1 Einleitung 1 2 Maude Funktionale Module Systemmodule Full-Maude Full-Maude als Erweiterung von Maude Narrowing in Full-Maude Narrowing als Generalisierung von Termersetzung Die Narrowing Implementierung in Full-Maude Funktional-logische Programmierung in Full-Maude Nicht-deterministische Berechnungen Gleichheitsconstraint Freie Variablen Residuation Zusammenfassung 15 ii

3 1 Einleitung Funktional-logische Sprachen kombinieren zwei Programmierparadigmen: die logische Programmierung und die funktionale Programmierung. Daraus entstehen besondere Eigenschaften, die funktional-logischen Programmiersprache zu eigen sind. In Full-Maude, der Erweiterung der Sprache Maude, können diese Eigenschaften reproduziert werden. Maude ist eine Programmier- und Spezikationssprache deren Programme aus Gleichungen und Rewrite-Regeln bestehen, welche durch Termersetzung ausgewertet werden. In der Erweiterung von Maude namens Full-Maude ist Narrowing implementieren. Narrowing kann eingesetzt werden, um Lösungen für das Problem zu nden, ob eine Termersetzung für einen Term mit freien Variablen durchgeführt werden darf. Narrowing kann auch genutzt werden, um Instanzen für freie Variablen zu generieren. Wie oben beschrieben sind die Sprache Maude und die Erweiterung Full-Maude geeignet, typische funktional-logische Programmeigenschaften zu implementieren. Das bedeutete nicht-deterministische Programmierung, das Ausnutzen von Constraints und das Suchen auf ungebunden Variablen lassen sich in Full-Maude umsetzen[esc14]. Im Folgenden wird zunächst Maude vorgestellt, wobei die Unterscheidung zwischen funktionalen und Systemmodulen eingegangen und die Ausführung von Programmen kurz erklärt wird. Dann wird Full-Maude und vor allem Narrowing in Full-Maude beschrieben. Schlieÿlich werden besondere Features der funktional-logischen Programmierung, wie nicht-deterministische Berechnungen und die Auswertung von Ausdrücken mit freien Variablen vorgestellt und gezeigt wie diese in Full-Maude reproduziert werden können. 1

4 2 Maude Maude ist eine höhere Programmier- und Spezikationssprache, welche auf Termersetzung basiert. Maude-Programme sind in Module aufgeteilt, welche aus einer Signatur, Gleichungen und Termersetzungsregeln bestehen. Gleichungen und Termersetzungsregeln haben eine einfache semantische Bedeutung, nämlich die Ersetzung von Instanzen der linken Seite durch passende Instanzen der rechten Seite. Besteht ein Maude-Modul nur aus einer Signatur und Gleichungen, wird es funktional genannt und wird durch Vereinfachung der Gleichungen ausgewertet. Enthält es auch Termersetzungsregeln so heiÿt es Systemmodul und wird durch Übergänge zwischen Zuständen ausgewertet. Diese Übergänge stellen die Anwendung der Termersetzungsregeln von links nach rechts dar. Auf diese Weise erlaubt es Maude sowohl deterministische, als auch nebenläuge, nichtdeterministische Berechnungen auszuführen und enthält einen funktionalen Teil, welcher eigenständig genutzt werden kann. 2.1 Funktionale Module Ein funktionales Modul in Maude besteht aus Signaturen, welche Datentypen und Operationen deklarieren, und Gleichungen, welche die Operationen denieren. Ein rein funktionales Modul zeichnet sich durch seine Schlüsselwörter aus und besitzt die Struktur: fmod <ModuleName> is <DeclarationsAndStatements> endfm Ein einfaches Beispiel für ein funktionales Modul ist die Denition der Addition auf den Peano-Zahlen mittels Gleichungen: fmod SIMPLE NAT is sort Nat. op zero : > Nat [ctor]. op s_ : Nat > Nat [ctor]. op _+_ : Nat Nat > Nat [comm]. vars N M : Nat. eq zero + N = N. eq s N + M = s (N + M). endfm In diesem Beispiel wird eine einfache Algebra über den natürlichen Zahlen beschrieben. In der Signatur werden die Sorte Nat und ihre beiden Konstruktoren (gekennzeichnet durch das Schlüsselwort ctor) deklariert. Auÿerdem wird der Operator + auf der Sorte Nat deklariert und deniert, dass dieser kommutativ ist (gekennzeichnet durch das Schlüsselwort comm). Der Operator wird dann im Sinne der Addition auf den Peano-Zahlen durch 2

5 2 Maude Gleichungen deniert. In Maude können neben Sorten auch Untersorten deklariert werden. Beispielsweise könnten wir eine Untersorte NzNat deklarieren, welche sämtliche natürliche Zahlen enthalten soll, die nicht Null sind: subsort NzNat < Nat. Die Operatoren könnten dann entsprechend angepasst werden: op zero : > Nat [ctor]. op s_ : Nat > NzNat [ctor]. op _+_ : Nat Nat > Nat [comm]. op _+_ : NzNat Nat > NzNat [comm]. Eine Berechnung in einem funktionalen Modul ist die Vereinfachung von Termen mit Hilfe von Gleichungen. Bei einem Vereinfachungsschritt für einen Term wird nach einer Belegung für die Variablen in einer linken Gleichungsseite gesucht, durch die der Term und die Gleichungsseite identisch werden. Der Term wird dann durch die rechte Gleichungsseite unter dieser Belegung ersetzt. Werden solche Vereinfachungsschritte wiederholt, bis keine linke Gleichungsseite mehr angewendet werden kann, so erhält man die kanonische Form des Terms. In einem funktionalen Modul sollte diese für jeden Ausdruck erreichbar sein und nicht von der Auswahl der Gleichungen in den Vereinfachungsschritten abhängen. Das heiÿt ein funktionales Modul sollte konuent und terminierend sein. 1 Erhält man sämtliche kanonische Formen aus Termen, die aus Konstruktoren und Operatoren gebildet werden, so bilden diese zusammen mit den Operatoren genau die im Programm beschriebene Algebra. In unserem Beispiel sind diese kanonischen Formen genau die Menge der Peano-Zahlen {zero, s zero, s s zero,...}. Im Maude Interpreter kann eine Vereinfachung durch das Schlüsselwort reduce eingeleitet werden: Maude> load simple nat.maude Maude> reduce s (s (zero)) + s (zero). reduce in SIMPLE NAT : s s zero + s zero. rewrites: 3 in 0ms cpu (0ms real) (~ rewrites/second) result Nat: s s s zero Hierbei wird der Term so lange vereinfacht, bis keine Gleichung mehr anwendbar ist. Gleichungen können in Maude mit dem Schlüsselwort noexec versehen werden, was dazu führt, dass sie nicht für Vereinfachungen verwendet werden und somit zunächst nur der Spezikation dienen. Weiterhin können Operatoren mit Attributen wie comm versehen werden, um auf bestimmte mathematische Eigenschaften hinzuweisen. Assoziativität und Kommutativität sollte in Maude zum Beispiel nur durch dieses Schlüsselwort ausgedrückt werden, da sonst nicht-terminierenden Vereinfachungen entstehen können. 1 mehr in [Cla+15], Kapitel 4.7 3

6 2 Maude Maude kennt neben Sorten auch noch kinds. Werden zusammenhängende Komponenten von Sorten aus der Ordnungsrelation auf den Sorten gebildet, so hat jede dieser Komponenten einen zugeordneten kind. Jeder Term hat somit auch einen zugeordneten kind. Hat ein Term keine Sorte, aber einen kind, so handelt es sich um einen Error-Term. Dabei werden kinds implizit durch Maude bereitgestellt. Denieren wir zum Beispiel op p_ : NzNat > NzNat dann wird dem Term p zero der kind [NzNat] zugeordnet, jedoch keine Sorte. kinds können auch explizit in der Deklaration von Operatoren benutzt werden. Werden Argumente als kinds deklariert, so gilt die Funktion als deniert für alle Argumente, deren Resultat bei der Funktionsauswertung eine Sorte haben, für alle anderen Argumente liefert die Funktionsauswertung nur einen Error-Term. 2.2 Systemmodule Systemmodule unterscheiden sich grundlegend von funktionalen Modulen. In Systemmodulen werden, zusätzlich zu der Signatur und Gleichungen, Termersetzungsregeln festgelegt, welche ähnlich wie die Gleichungen bei der Vereinfachung immer von links nach rechts angewendet werden. Die Termersetzungsregeln müssen allerdings weder ein kon- uentes noch ein terminierendes System bilden. Bei einem Termersetzungsschritt werden durch Maude zufällige Regeln, deren linke Seite instantiiert werden kann, ausgewählt, um einen Teilterm des Terms umzuschreiben. Das Rewriting ist also im Allgemeinen nicht-deterministisch. Das folgende Modul deniert die additive Zerlegung in die Zahlen eins, zwei und drei mit Hilfe von drei Rewrite-Regeln: mod DECOMPOSITION is protecting SIMPLE NAT. sort NatList. subsort Nat < NatList. op _ _ : NatList NatList > NatList [comm assoc ctor]. endm rl [decomposite1] : s s X:Nat => s(zero) s X:Nat. rl [decomposite2] : s s s X:Nat => s(s(zero)) s X:Nat. rl [decomposite3] : s s s s X:Nat => s(s(s(zero))) s X:Nat. Das Modul wird mit mod... is... endm deklariert, was darauf hinweist, dass es sich um ein Systemmodul handelt. Am Anfang des Moduls wird das funktionale Modul SIMPLE-NAT importiert, welches im letzten Abschnitt vorgestellt wurde. Dann wird die Sorte der Listen über den natürlichen Zahlen deklariert. Einzelne natürliche Zahlen sollen auch zu der Sorte NatList gehören, entsprechend wird Nat als Untersorte deniert. 4

7 2 Maude Dann wird ein Listenkonstruktor _ _ deklariert, welcher zwei Listen konkateniert. Die in diesem Modul denierte Version der Verkettung von Listen ist assoziativ und kommutativ, dass heiÿt die Gleichheit von Listen hängt nicht von der Reihenfolge der Elemente oder der Listenkonkatenation ab. 2 Es werden dann drei Regeln für die additive Zerlegung natürlicher Zahlen in Listen der Zahlen Eins, Zwei und Drei deniert. Mit Hilfe dieser Rewrite-Regeln kann nun Rewriting modulo Gleichungen angewendet werden. Beim Rewriting modulo Gleichungen im Sinne von Maude wird der Term zunächst mit Hilfe der Gleichungen auf seine kanonische Form gebracht und dann ein Teilterm mit einer passenden Rewrite-Regel durch einen anderen Term ersetzt. Das nden einer passende Rewrite-Regel für den Teilterm erfolgt dabei auf die selbe Art wie bei Gleichungen. Das heiÿt es wird eine Belegung für eine linke Regelseite gesucht, die zu einer Identität von Teilterm und Regelseite führt, und der Teilterm dann durch die rechte Regelseite unter der selben Belegung ersetzt. Mit dem search-befehl können in Maude nun mögliche Rewrite-Schritte um einen Term t in einen Term t umzuschreiben, gesucht werden. Dabei können Anzahl der Rewrite- Schritte, Tiefe der Suche und Art der Relation (=>*, =>+, =>!, etc. 3 ) ausgewählt werden. Dabei werden in t im Gegensatz zum Narrowing allerdings keine Variablen neu instantiiert. Mit search können zum Beispiel alle Zerlegungen der Zahl Drei angezeigt werden: Maude> search in DECOMPOSITION : s s s zero =>* Ns:NatList. Solution 1 (state 0) states: 1 rewrites: 0 in 0ms cpu (0ms real) (~ rewrites/second) Ns:NatList > s s s zero Solution 2 (state 1) states: 2 rewrites: 1 in 0ms cpu (0ms real) (~ rewrites/second) Ns:NatList > s zero s s zero Solution 3 (state 3) states: 4 rewrites: 4 in 0ms cpu (0ms real) (~ rewrites/second) Ns:NatList > s zero s zero s zero No more solutions. Es kann auch nach möglichen Teilzerlegungen gesucht werden: Maude> search in DECOMPOSITION : s s s X:Nat =>* Ns:NatList s s zero. Solution 1 (state 2) states: 3 rewrites: 2 in 0ms cpu (0ms real) (~ rewrites/second) Ns:NatList > s X:Nat No more solutions. 2 Es handelt sich hierbei also eher um Multimengen statt Listen. 3 Eine ausführliche Beschreibung ndet sich in [Cla+15] 5

8 2 Maude Würde die in diesem Fall ungebundene Variable X:Nat mit Peano-Zahlen instantiiert werden, so würden noch weitere Lösungen hinzukommen. Dies ist in Maude ohne die Erweiterung allerdings nicht möglich. 6

9 3 Full-Maude 3.1 Full-Maude als Erweiterung von Maude In Maude wurde von Anfang an eine Schnittstelle für Metaprogrammierung vorgesehen. Metaprogrammierung meint dabei die Umprogrammierung der Programmiersprache selbst in der Programmiersprache. Eine Einsatzmöglichkeit von Metaprogrammierung in Maude ist die Erweiterung von Maude selbst. Dies wurde in der Spracherweiterung Full- Maude umgesetzt. Full-Maude enthält sämtliche Features von Maude, sowie verschiedene Erweiterungen wie eine Notation für objekt-orientierte Programmierung und ein generalisierte Form der Termersetzung namens Narrowing. Narrowing ist für die funktional-logische Programmierung von groÿer Bedeutung, da es die Auswertung von Ausdrücken mit freien Variablen erlaubt. 3.2 Narrowing in Full-Maude Narrowing als Generalisierung von Termersetzung In 2.2 wurde Rewriting mittels Termersetzungsregeln erläutert. Rewriting mit Narrowing verallgemeinert dieses. Der Hauptunterschied besteht darin, dass bei dem Suchen nach Belegungen, um eine Identität zwischen Term und linker Regelseite herzustellen, auch freie Variablen in dem Term mit Belegungen versehen werden können. Dies erlaubt deutlich erweiterte Programmierung mit freien Variablen. So kann zum Beispiel die Frage, ob ein Term mit freien Variablen mit einer Instantiierung dieser in einen anderen Term umgeschrieben werden kann, durch eine Ausführung von Rewriting mit Narrowing beantwortet werden Die Narrowing Implementierung in Full-Maude In Full-Maude existiert eine Narrowing-Implementierung von Santiago Escobar. Betrachten wir wieder als Beispiel die Addition, diesmal mit Rewrite-Regeln statt Gleichungen und der Implementierung der natürlichen Zahlen aus Maude selbst: mod NATRL is op _add_ : Nat Nat > Nat. rl 0 add M:Nat => M:Nat. rl s M:Nat add N:Nat => s (M:Nat + N:Nat). endm 7

10 3 Full-Maude Ein Narrowing-Schritt für den Term X add 0 wäre dann X add 0 {X 0, add1} 0. Es würde also eine Belegung für die freie Variable X gefunden werden, unter der eine Rewrite-Regel angewendet werden kann. Das Resultat ist dann die rechte Seite dieser Rewrite-Regel mit der selben Belegung. Ein anderer Narrowing-Schritt wäre X add 0 {X s Y,add2} s (Y add 0). Es lässt sich das search-kommando nun auch mit Narrowing benutzen, verwenden wir wieder das Beispiel aus 2.2, so erhalten wir mehr Lösungen. Maude> (search [2] in DECOMPOSITION : s s s X:Nat ~>* Ns:NatList s s zero.) Solution 1 Ns:NatList > s X:Nat Solution 2 Ns:NatList > s s s zero ; X:Nat > s s zero No more solutions. Die Anzahl der Lösungen wurde in diesem Fall auf zwei beschränkt. Bei der zweiten Lösung erfolgt die Instantiierung der Variable X durch Narrowing. Diese Lösung haben wir im Beispiel in 2.2 nicht erhalten. 8

11 4 Funktional-logische Programmierung in Full-Maude Funktional-logische Programmierung ist eine Form der deklarativen Programmierung. Dabei werden wichtige Paradigmen der funktionalen und der logischen Programmierung vereint. Funktionale Programme bestehen aus Daten und Funktionen, ihre Semantik entspricht Funktionsauswertungen. Logische Programme bestehen aus Fakten und Regeln aus denen mit Hilfe von Inferenzsystemen Schlüsse berechnet werden können. Logische Programme können auch mit freien Variablen ausgewertet werden, indem nach passenden Werten gesucht wird. Die besonderen Vorteile funktionaler Sprachen, wie die Möglichkeit der Bedarfsauswertung, von polymorphen Typen und Funktionen höherer Ordnung werden in funktionallogischen Programmiersprachen mit den Vorteilen der logischen Programmierung, wie Berechnungen mit partiellen Informationen und Constraint-Solving, kombiniert. Aus mathematischer Sicht basieren funktionale Programmiersprachen auf dem λ-kalkül, während logische auf der Prädikatenlogik erster Stufe aufbauen. Bei der Vereinigung dieser beiden grundverschiedenen Systeme kann Narrowing eingesetzt werden 1. Maude bietet oensichtlich Möglichkeiten der rein funktionalen Programmierung, was durch die Aufteilung in funktionale und Systemmodule deutlich wird. Die nicht-deterministische Auswertung ist in durch das nicht-deterministische Rewriting vorhanden. Im Folgenden wird daher auf die Reproduktion der besonderen Eigenschaften des Nicht- Determinismus in funktional-logischen Programmiersprachen und das Rechnen mit freien Variablen und Constraints eingegangen. 4.1 Nicht-deterministische Berechnungen Nicht-Determinismus bedeutet, dass ein Ausdruck zu unterschiedlichen Ergebnissen ausgewertet werden kann. In Curry ist es möglich Nicht-Determinismus durch den Operator? auszudrücken. In dem folgenden Programm kann nicht zugesichert werden, zu welcher Zahl die Konstante coin ausgewertet wird, möglich sind 0 und 1. coin = 0? 1 In Maude würde man diesen Nicht-Determinismus durch Rewrite-Regeln ausdrücken: op coin : > Nat. rl coin => 0. rl coin => 1. 1 Vergleiche [Han13] 9

12 4 Funktional-logische Programmierung in Full-Maude Werden in Curry nicht-deterministische Parameter an deterministische Funktionen übergeben, so kann das Ergebnis von der Auswertungsstrategie abhängen. Nehmen wir etwa das Curry-Programm double : : Int > Int double x = x + x welches eine einfache Funktion deniert. Bei der Auswertung von double coin variiert nun die Menge der möglichen Ergebnisse je nach Auswertungszeitpunkt des nichtdeterministischen Arguments. Wird das Argument vor der Funktionsauswertung ausgewertet (call-time choice), so ist die Menge der möglichen Ergebnisse des Aufrufs {0, 2}. Wird das Argument ausgewertet, wenn es während der Funktionsauswertung aufgerufen wird (run-time choice), so erhalten wir {0, 1, 2} als mögliche Ergebnisse von double coin. Ähnliche Ergebnisse können auch in Maude erzielt werden. Dafür deklarieren wir double und denieren passende Rewrite-Regeln: op double : Nat > Nat. rl double(n:nat) => N:Nat + N:Nat. Führen wir nun mit Maude ein search aus, so erhalten wir drei Ergebnisse für double(coin): Maude> search in NATLR : double(coin) =>! N:Nat. N:Nat > 0 N:Nat > s 0 N:Nat > s s 0 No more solutions. In diesem Fall werden in Maude alle möglichen Rewrite-Schritte probiert, was zu der Ergebnismenge {0, 1, 2} führt. Hierbei handelt es sich allerdings weder um eine calltime choice noch um eine run-time choice Semantik, da alle möglichen Rewrite-Schritte ausprobiert werden. Es ist möglich kinds einzusetzen, um die Auswertungsstrategie zu ändern. Wir können zum Beispiel die Signatur von coin ändern, so dass nicht mehr zugesichert wird, dass kein Error-Term geliefert wird: op coin : > [Nat]. Das führt dazu das auf den gesamten Term double(coin) keine Rewrite-Regeln mehr angewendet werden können, da in der Rewrite-Regel von double die Variable von der Sorte Nat sein muss. Es muss also der Teilterm coin umgeschrieben werden, bevor die Regel angewendet werden kann. Nach dieser Änderung liefert search nur noch {0, 2} als Ergebnisse. Um eine echte run-time choice Semantik zu erzeugen, erlauben wir den Error-Term als Parameter für double. Auÿerdem setzten wir das Parameter auf frozen. Dies führt dazu, dass keine Rewrite-Regel auf diesen Teilterm angewendet werden darf. Daraus folgt, dass zunächst die Regel für double angewendet werden muss. 10

13 4 Funktional-logische Programmierung in Full-Maude op double : [Nat] > Nat [frozen (1)]. rl double(n:[nat]) => N:[Nat] + N:[Nat]. Wir erhalten nun wieder {0, 1, 2} als Ergebnismenge. Ein typisches Beispiel für die Anwendung von Nicht-Determinismus ist die Permutation von Listen. Dabei wird eine Funktion permute deniert, welche eine nicht-deterministische insert Funktion aufruft und nicht-deterministisch Permutationen der Liste zurück liefert. Dies kann in Maude umgesetzt werden: mod PERMUTATION is protecting LIST{Nat}. vars X,Y : Nat. var XS : List{Nat}. op permute : List{Nat} > [List{Nat}]. rl permute(nil) => nil. rl permute(x XS) => insert(x, permute(xs)). op insert : Nat List{Nat} > [List{Nat}]. rl insert (X, nil) => X nil. rl insert (X, Y XS) => X Y XS. rl insert (X, Y XS) => Y insert(x, XS). endm In diesem Fall wird wieder call-time choice benutzt. Nun lassen sich zum Beispiel nichtdeterministisch alle Permutationen der Liste [1 2 3] berechnen, die mit 2 anfangen: Maude> search in PERMUTATION : permute(1 2 3) =>! 2 N:List{Nat}. N:List{Nat} > 1 3 N:List{Nat} > 3 1 No more solutions. 4.2 Gleichheitsconstraint In funktional-logischen Programmiersprachen kann die Anwendung von Gleichungen an die Erfüllung von Bedingungen geknüpft werden. In Curry gibt es dafür den Operator =:=. Dieser Operator kann als ein Constraint verstanden werden, welches erfüllt werden muss, damit die Gleichung angewendet werden kann. Dieser Gleichheitsconstraint e 1 =:=e 2 wird genau dann erfüllt, wenn eine Belegung für e 1 und e 2 gefunden werden kann, so dass e 1 ==e 2 gilt. In Curry kann weiterhin der Operator &> verwendet werden, um einen Constraint an einen Ausdruck zu binden. Dabei wird ein Term c &> e mit Constraint c und Ausdruck e auch als Constraint Expression bezeichnet. Ein Beispiel für eine solche Constraint Expression ist die eine Denition der Subtraktion auf den Peano-Zahlen: 11

14 4 Funktional-logische Programmierung in Full-Maude data Peano = Zero P Peano add : : Peano > Peano > Peano add Zero n = n add (P n) m = P ( add n m) sub n m = add x m =:= n &> x where x f r e e In diesem Beispiel wird eine freie Variable x eingeführt, mit einer Suche auf ihr der Gleichheitsconstraint gelöst und diese als Ergebnis der Subtraktion ausgegeben. Der Gleichheitsconstraint kann in Maude mit Hilfe einer Konstanten success und einer Rewrite-Regel deniert werden: sort Success. op success : > Success [ctor]. op _=:=_ : Nat Nat > [Success] [comm]. rl X:Nat =:= X:Nat => success. Es wird in diesem Fall angenommen, dass als Resultat von nicht-deterministischen Operatoren immer als kind deklariert wird. Wie oben gezeigt wurde, führt dies zu einer call-time choice Semantik, wenn die Funktionsargument als Sorten deklariert werden. Dies ist für den Operator =:= der Fall. Ansonsten würde coin =:= coin zu success ausgewertet werden, ohne das der Nicht-Determinismus aufgelöst würde. Um eine Constraint Expression zu ermöglichen muss noch ein weiterer Operator &> de- niert werden. Diesen nennen wir in Maude in um und denieren ihn folgendermaÿen: op _>>_ : [Success] [Nat] > [Nat] [frozen (2) strat (1 0)]. rl success >> X:[Nat] => X:[Nat]. In der Deklaration des Operators ist das zweite Argument als frozen markiert, was dazu führt, dass dieses Argument nicht durch Rewriting ersetzt werden kann. Dies hat zur Konsequenz, dass das zweite Argument niemals durch die Anwendung einer Regel verändert wird, bevor das erste Argument zu success umgeschrieben wurde, was der Semantik des Constraint entspricht. Der Operator ist weiterhin mit strat 1 0 gekennzeichnet, was bedeutet, dass zunächst das erste Argument vereinfacht wird, bevor der gesamte Term vereinfacht werden kann. Dies ist wichtig, da auf diese Weise rekursive Vereinfachungen abgefangen werden können. Mit Hilfe des Gleichheitsconstraints haben wir die Voraussetzung um ungebundene Variablen in Maude Programmen zu benutzen. 12

15 4 Funktional-logische Programmierung in Full-Maude 4.3 Freie Variablen Ungebundene oder logische Variablen sind ein Merkmal von funktional-logischen Sprachen. Auch in Curry ist es möglich, freie Variablen zu benutzen. Diese Variablen werden mit where... free deklariert und es wird automatisch nach passenden Belegungen gesucht. Im folgenden Beispiel sind ys und e freie Variablen: l a s t xs = ys++[e ] =:= xs &> e where ys, e f r e e Die Funktion last berechnet das letzte Element einer Liste. Bei der Auswertung werden ys und e mit passenden Werten belegt. Das gleiche Verhalten kann in Full-Maude erzeugt werden. Dazu wird zunächst das Gleichheitsconstraint auf den in 2.2 denierten Listen von natürlichen Zahlen 2 deniert: mod CONSTRAINT is protecting DECOMPOSITION. sort Success. op success : > Success [ctor]. op _=:=_ : NatList NatList > [Success] [comm]. rl X:NatList =:= X:NatList => success. endm op _>>_ : [Success] [NatList] > [NatList] [frozen (2) strat (1 0)]. rl success >> X:[NatList] => X:[NatList]. Mit Hilfe dieses Operators können wir jetzt die Funktion last wie in Curry denieren: op last : NatList > [Nat]. rl last(ls:natlist) => (R:NatList L:Nat) =:= LS:NatList >> L:Nat [nonexec]. Mit Narrowing können wir damit das letzte Element einer Liste berechnen. In dieser Denition kommen zwei freie Variablen R und L vor. Aus diesem Grund müssen wir das noexec-attribut verwenden, da Maude dies sonst nicht erlaubt. 4.4 Residuation In der logischen Programmierung gibt es verschiedene Strategien um das Lösen von mehreren Constraints zu beschleunigen. Residuation ist eine solche Strategie, deren Ansatz darin besteht, das Lösen von Constraints zu pausieren, bis eine neue Instantiierung durch ein anderes Constraint erfolgt ist. Das Hauptprinzip hinter Residuation ist so lange mit einem Funktionsaufruf in einem Constraint zu warten, bis die nicht-deterministische Auswertung der Argumente beendet ist. Residuation steht unter anderem in Curry zur Verfügung. Um Residuation in Maude zu ermöglichen, wird zunächst ein Operator für die Kombination von Constraints deniert: 2 Allerdings ohne die Kommutativität der Konkatenation! 13

16 4 Funktional-logische Programmierung in Full-Maude op _&_ : [Success] [Success] > [Success] [assoc comm id: success]. Da Maude immer Vereinfachungen ausführt bevor Termersetzungsregeln angewendet werden, ist es relativ einfach Residuation umzusetzen, indem man die Funktionen als Gleichungen und die Instantiierung als Rewriting-Regeln deniert. Ein einfaches Programm, welches eine Variable nicht-deterministisch mit natürlichen Zahlen instantiiert und die Addition als Gleichungen deniert, wurde von Escobar folgendermaÿen implementiert: op nat : Nat > [Success]. rl nat(0) => success. rl nat(s N) => nat(n). op _+_ : Nat Nat > [Nat]. eq 0 + M = M. eq (s N) + M = s (N + M). Es kann nun eine Operation deniert werden, welche Residuation zur Berechnung benutzt: op sub : Nat > Nat > [Nat]. rl sub(x:nat, Y:Nat) => nat(z:nat) & Z:Nat + Y:Nat =:= X:Nat >> Z:Nat [nonexec]. Es wird dabei immer zuerst Z instantiiert, bevor die Addition vereinfacht wird um den Constraint zu lösen. 14

17 5 Zusammenfassung In dieser Arbeit wurde beschrieben, wie funktional-logische Programmierung in Maude funktioniert. Dazu wurde die Programmier- und Spezikationssprache kurz beschrieben, wobei auf Syntax und Semantik der funktionalen und Systemmodule von Maude eingegangen wurde. Es wurde dann die Erweiterung von Maude mit dem Namen Full-Maude und das in dieser enthaltene Modul für Narrowing vorgestellt. Im Anschluss wurde gezeigt, wie Nicht-Determinismus, Constraints und freie Variablen in Full-Maude so verwendet werden können, wie es in funktional-logischen Sprachen wie Curry möglich ist. Es wurde ersichtlich, dass Konzept aus Curry, wie Residuation, durch die Syntax und Semantik von Maude-Programmen einfach umgesetzt werden können. Durch die Unterstützung von und Kombination aus gleichungsbasierten Vereinfachungen und regelbasierter, nicht-deterministischer Termersetzung sind mächtige Werkzeuge für diese Anwendungsfälle gegeben. Bisher wurde nur ein Narrowing Ansatz in Full-Maude umgesetzt. Needed Narrowing, eine Technologie die in Curry vorhanden ist und die der Bedarfsauswertung in funktionalen Programmen ähnelt, fehlt bislang in Maude. Wie performant die von Escobar implementierte Narrowing Lösung im Vergleich zu anderen Sprachen wie Curry ist, wurde in dieser Arbeit, wie auch in Escobars Aufsatz, nicht evaluiert. 15

18 Literatur [Cla+15] Manuel Clavel u. a. Maude Manual (Version 2.7). März [Esc14] [Han13] Santiago Escobar. Functional Logic Programming in Maude. In: Specication, Algebra, and Software. Hrsg. von Shusaku Iida, José Meseguer und Kazuhiro Ogata. Bd Lecture Notes in Computer Science. Springer Berlin Heidelberg, 2014, S M. Hanus. Functional Logic Programming: From Theory to Curry. In: Programming Logics - Essays in Memory of Harald Ganzinger. Springer LNCS 7797, 2013, S