Funktionale Programmierung mit Caml Klaus Becker 2004

Programmieren mit Funktionen akzeptor 1 g u Ok! 1 0 0 0 1 1 0 1 1

Funktionen als Programme Teil 1 Funktionen als Programme

Die Welt der Automaten 1 g u 1 Mit Hilfe endlicher Automaten kann man formale Sprachen erkennen. Der dargestellte endliche Automat erkennt die Sprache der 0-1-Worte mit gerader Parität (gerader Anzahl von 1en).

Eine Automatenbeschreibung 1 g u 1 Zustandsmenge: Z = {g, u} Anfangszustand: za = g Endzustände: zE = {g} Eingabemenge: E = {0, 1} Überführungsfunktion: : (g, 0)  g : (g, 1)  u : (u, 0)  u : (u, 1)  g

Funktionale Modellierung Zustandsmenge: Z = {g, u} Eingabemenge: E = {0, 1} Anfangszustand: za = g Endzustände: zE = {g} Überführungsfunktion: : (g, 0)  g : (g, 1)  u : (u, 0)  u : (u, 1)  g type zustandP = g | u;; type eingabeP = e0 | e1;; let anfangszustandP = g;; let endzustandP = function g -> true | u -> false;; let deltaP = function (g, e0) -> g | (g, e1) -> u | (u, e0) -> u | (u, e1) -> g ;;

Funktionale Modellierung anfangszustandP endzustandP: g  true deltaP: (g, e1)  u g u g u true false g u e0 e1 zustand zustand bool zustand eingabe type zustandP = g | u;; type eingabeP = e0 | e1;; let anfangszustandP = g;; let endzustandP = function g -> true | u -> false;; let deltaP = function (g, e0) -> g | (g, e1) -> u | (u, e0) -> u | (u, e1) -> g ;;

Modellierungskonzept type zustandP = g | u;; type eingabeP = e0 | e1;; let anfangszustandP = g;; let endzustandP = function g -> true | u -> false;; let deltaP = function (g, e0) -> g | (g, e1) -> u | (u, e0) -> u | (u, e1) -> g ;; Typdeklaration Konstantendeklaration Funktionsdeklaration Objektbereiche werden mit Hilfe von Typen beschrieben. Eigenschaften von Objekten und Zusammenhänge zwischen Objekten mit Hilfe von Funktionen (und Konstanten).

Auswertung von Deklarationen #Type zustandP defined. #Type eingabeP defined. #anfangszustandP : zustandP = g #endzustandP : zustandP -> bool = <fun> #deltaP : zustandP * eingabeP -> zustandP = <fun> Auswertung durch Caml type zustandP = g | u;; type eingabeP = e0 | e1;; let anfangszustandP = g;; let endzustandP = function g -> true | u -> false;; let deltaP = function (g, e0) -> g | (g, e1) -> u | (u, e0) -> u | (u, e1) -> g ;; Benutzereingabe

Funktionsdeklaration Signaturanalyse Signatur der Funktion Auswertung: #deltaP : zustandP * eingabeP -> zustandP = <fun> Die Funktion deltaP ordnet einem Paar bestehend aus einem Objekt vom Typ zustandP und einem Objekt vom Typ eingabeP ein Objekt vom Typ zustandP zu. Benutzereingabe: type zustandP = g | u;; type eingabeP = e0 | e1;; ... let deltaP = function (g, e0) -> g | (g, e1) -> u | (u, e0) -> u | (u, e1) -> g ;; Funktionsdeklaration

Funktionsanwendung Auswertung: ... #deltaP : zustandP * eingabeP -> zustandP = <fun> #deltaP(u, e0);; - : zustandP = u Die Auswertung des funktionalen Ausdrucks delta(e0, g) liefert das Objekt u vom Typ zustand. Aktuelle Benutzereingabe: deltaP(u, e0);; Vorherige Benutzereingaben: type zustandP = g | u;; type eingabeP = e0 | e1;; ... let deltaP = function (g, e0) -> g | (g, e1) -> u | (u, e0) -> u | (u, e1) -> g ;;

Funktionsanwendung Die Auswertung des funktionalen Ausdrucks #endzustandP(deltaP(deltaP(anfangszustandP, e1), e1));; - : bool = true Benutzereingabe: endzustandP(deltaP(deltaP(anfangszustandP, e1), e1));; Die Auswertung des funktionalen Ausdrucks deltaP(deltaP(anfangszustandP, e1), e1) liefert das Objekt u vom Typ zustandP.

Funktionale Programme Ein funktionales Programm besteht aus einer Menge von Funktionsdeklarationen (und evtl. benötigten Typdeklarationen) und einem funktionalen Ausdruck (Berechnungsausdruck). Funktionaler Ausdruck Funktionsdeklarationen Benutzereingabe: deltaP(u, e0);; Benutzereingabe: type zustandP = g | u;; type eingabeP = e0 | e1;; ... let deltaP = function (g, e0) -> g | (g, e1) -> u | (u, e0) -> u | (u, e1) -> g ;;

Programmierkonzept type zustandP = g | u;; type eingabeP = e0 | e1;; ... let deltaP = function (g, e0) -> g | (g, e1) -> u | (u, e0) -> u | (u, e1) -> g ;; deltaP(u, e0);; Mit Funktionen kann man programmieren. Die Programme bestehen aus Funktionsdeklarationen und einem funktionalen Berechnungsausdruck.

Übung Entwickeln Sie ein funktionales Programm zur Simulation einer Ampelschaltung mit Tag-Nacht-Betrieb. Testen Sie das Programm.

Lösungsvorschlag type zustandA = ro | rg | ge | gr | aa;; type eingabeA = t | n;; type ausgabeA = Ooo | OOo | ooO | oOo | ooo;; let anfangszustandA = ge;; let deltaA = function (ro, t) -> rg | (rg, t) -> gr | (gr, t) -> ge | (ge, t) -> ro | (aa, t) -> ge | (ro, n) -> aa | (rg, n) -> aa | (gr, n) -> aa | (ge, n) -> aa | (aa, n) -> ge ;; let lambdaA = function (ro, t) -> OOo | (rg, t) -> ooO | (gr, t) -> oOo | ...

Teil 2 Kontrollstrukturen

Zielsetzung 1 0 0 0 1 1 0 1 1 Ok! g u 1 Es soll ein Akzeptor-System entwickelt werden, mit dem eine Folge von Eingaben verarbeiten werden kann und rückgemeldet wird, ob diese Folge in einen Endzustand überführt.

Listen 1 [0; 0; 0; 1; 1; 0; 1; 1] true g u 1 Eine Liste in Caml besteht aus einer beliebigen, aber endlichen Anzahl von Elementen, die alle den gleichen Typ haben.

Listenkonstruktoren Leere Liste: Die leere Liste wird mit [] dargestellt. Hinzufügen eines Elementes: Mit Hilfe des Hinzufügoperators :: kann ein Element vorne in eine Liste eingefügt werden. Bsp.: 1 :: [2; 3]  [1; 2; 3]

Spezifikation des Automatensimulators simulatorP Zustand Zustand nach der Verarbeitung der Eingaben Eingabeliste Bsp.: simulatorP(g, [e0; e1; e1; e1])  u Spezifikation: akzeptorP Eingabeliste true / false Bsp.: akzeptorP([e0; e1; e1; e1])  false

Rekursive Problemreduktion Fall 1: Verarbeite eine leere Eingabenliste simulartorP(g, [])  g Fall 2: Verarbeite eine nicht-leere Eingabenliste simulatorP(g, [e1; e0; e1])  simulatorP(u, [e0; e1])] g g Rekursive Problemreduktion: Reduktion des Problems auf ein entsprechendes, aber „verkleinertes“ Problem

Reduktionsregeln Fall 1: Verarbeite eine leere Eingabenliste simulartorP(g, [])  g Fall 2: Verarbeite eine nicht-leere Eingabenliste simulatorP(g, [e1; e0; e1])  simulatorP(u, [e0; e1])] g g let rec simulatorP = function (z, []) -> z | (z, e::r) -> simulatorP(deltaP(e,z), r);;

Reduktionsketten let rec simulatorP = function (z, []) -> z | (z, e::r) -> simulatorP(deltaP(e,z), r);; simulatorP(g, [e1; e0; e1])  simulatorP(deltaP(g, e1), [e0; e1])  simulatorP(delta(deltaP(g, e1), e0), [e1])  simulatorP(delta(delta(deltaP(g, e1), e0), e1), [])  delta(delta(deltaP(g, e1), e0), e1)  delta(delta(u, e0), e1)  delta(u, e1)  g Caml berechnet mit Hilfe solcher Reduktionsketten den Wert des Ausgangsterms.

Paritäts-Akzeptor #simulatorP : zustandP * eingabeP list -> zustandP = <fun> #akzeptorP : eingabeP list -> bool = <fun> let rec simulatorP = function (z, []) -> z | (z, e::r) -> simulatorP(deltaP(z,e), r);; let akzeptorP = function w -> endzustandP(simulatorP(anfangszustandP,w));;

Test des Akzeptors #akzeptorP([e1;e0;e1]);; - : bool = true

Funktionskomposition Kontrollstrukturen Fallunterscheidung let rec simulatorP = function (z, []) -> z | (z, e::r) -> simulatorP(deltaP(e,z), r);; let akzeptorP = function w -> endzustandP(simulatorP(anfangszustandP,w));; Rekursion Funktionskomposition Funktionsdeklarationen werden mit Hilfe von - Funktionskomposition, - Fallunterscheidungen und - Rekursion aufgebaut.

Übung Spezifikation: simulatorA Zustand Liste mit den erzeugten Ausgaben Eingabeliste Bsp.: simulatorA(ro, [t; t; t; t])  [OOo; ooO; oOo; Ooo] Entwickeln Sie eine Funktionsdeklaration zur Implementierung eines Ampelsimulators.

Lösungsvorschlag #simulatorA : zustandA * eingabeA list -> ausgabeA list = <fun> #- : ausgabeA list = [Ooo; OOo; ooO; ooO; ooo; oOo] ... (* Deklaration der Ampel *) let rec simulatorA = function (z, []) -> [] | (z, e::r) -> lambdaA(z,e) :: simulatorA(deltaA(z,e), r);; simulatorA(anfangszustandA, [t;t;t;t;n;n]);;

Teil 3 Datenstrukturen

Zielsetzung let anfangszustandP = g;; let endzustandP = function g -> true | u -> false;; let deltaP = function (g, e0) -> g | (g, e1) -> u | (u, e0) -> u | (u, e1) -> g ;; Ok! 0 0 0 1 1 0 1 1 Es soll ein universelles Akzeptor-System entwickelt werden, mit dem eine Folge von Eingaben mit einem beliebig vorgegebenen Automaten verarbeiten werden kann.

Spezifikation des Automatensimulators Automatenbeschreibung Zustand nach der Verarbeitung der Eingaben Zustand Eingabeliste Bsp.: simulator((g, (g  true, u  false), ...), g, [e0; e1; e1; e1])  u Spezifikation: akzeptor Automatenbeschreibung true / false Eingabeliste Bsp.: akzeptor((g, (g  true, u  false), ...), [e0; e1; e1; e1])  false

Automatenbeschreibung Spezifikation: simulator Automatenbeschreibung Zustand nach der Verarbeitung der Eingaben Zustand Eingabeliste Bsp.: simulator((g, (g  true, u  false), ...), g, [e0; e1; e1; e1])  u Eine Automatenbeschreibung ist ein Tripel (az, ez, de) mit: - az ist eine Konstante eines Zustandstyps 'a („Anfangszustand“). - ez ist eine Funktion 'a  'b, die jedem Zustand aus 'a einen Wert aus 'b zuordnet („Endzustand“). - de ist eine Funktion 'a * 'c  'a, die jedem Zustand aus 'a und jeder Eingabe aus einem Eingabetyp 'c einen neuen Zustand aus 'a zuordnet („Delta“).

Reduktionsregeln #simulator : ('a * 'b * ('c * 'd -> 'd)) * 'd * 'c list -> 'd = <fun> #akzeptor : ('a * ('a -> 'b) * ('c * 'a -> 'a)) * 'c list -> 'b = <fun> let rec simulator = function ((az,ez,de), z, []) -> z | ((az,ez,de), z, e::r) -> simulator((az,ez,de), de(z,e), r);; let akzeptor = function ((az,ez,de), w) -> ez(simulator((az,ez,de), az, w));;

Test #akzeptor(automatP, wortP);; - : bool = false let rec simulator = function ... let akzeptor = function ... type zustandP = g | u;; type eingabeP = e0 | e1;; let anfangszustandP = g;; let endzustandP = function g -> true | u -> false;; let deltaP = function (g,e0)->g| (g,e1)->u| (u,e0)->u| (u,e1)->g;; let automatP = (anfangszustandP, endzustandP, deltaP);; let wortP = [e0; e1; e1; e1];; akzeptor(automatP, wortP);;

Datenstrukturen let rec simulator = function ((az,ez,de), z, []) -> z | ((az,ez,de), z, e::r) -> simulator(...);; Funktion Tupel Liste Objekte können mit Hilfe von Tupelbildung und Listen zu neuen Einheiten zusammen-gefasst werden. Funktionen können als Eingabeobjekte für weitere Funktionen benutzt werden.

Übung Spezifikation: simulator Automatenbeschreibung Liste mit den erzeugten Ausgaben Zustand Eingabeliste Bsp.: simulator((...), ro, [t; t; t; t])  [OOo; ooO; oOo; Ooo] Entwickeln Sie eine Funktionsdeklaration zur Implementierung eines Automatensimulators. Testen Sie den Simulator.

Lösungsvorschlag #simulator : ('a * ('b * 'c -> 'b) * ('b * 'c -> 'd)) * 'b * 'c list -> 'd list = <fun> #transduktor : ('a * ('a * 'b -> 'a) * ('a * 'b -> 'c)) * 'b list -> 'c list = <fun> #ampel : zustandA * (zustandA * eingabeA -> zustandA) * (zustandA * eingabeA -> ausgabeA) = ge, <fun>, <fun> #- : ausgabeA list = [Ooo; OOo; ooO; oOo; ooo; oOo] ... (* Deklaration der Ampel *) ... let rec simulator = function ((az, de, la), z, []) -> [] | ((az, de, la), z, e::r) -> la(z,e) :: simulator((az, de, la), de(z,e), r);; let transduktor = function ((az, de, la), w) -> simulator((az, de, la), az, w);; let ampel = (anfangszustandA, deltaA, lambdaA);; transduktor(ampel, [t;t;t;t;n;n]);;

Deklarative Programmierung Teil 4 Deklarative Programmierung

Programmierstile Programmierung mit Wertzuweisungen begin automat.anfangszustand; for i := 0 to eingaben.Count-1 do begin e := eingaben[i]; a := automat.ausgabe(e); automat.neuerZustand(e); ausgaben.Add(a); end; end; Programmierung mit Wertzuweisungen Programmierung mit Funktionsdeklarationen let rec simulator = function ((az, de, la), z, []) -> [] | ((az, de, la), z, e::r) -> la(z,e) :: simulator((az, de, la), de(z,e), r);; let transduktor = function ((az, de, la), w) -> simulator((az, de, la), az, w);; let ampel = (anfangszustandA, deltaA, lambdaA);; transduktor(ampel, [t;t;t;t;n;n]);;

Imperative Programmierung begin z := anfangszustand; for i := 0 to n-1 do begin e := eingaben[i]; a := ausgabe(e); z := neuerZustand(e); ausgaben[i] := a; end; end; Programmierung mit Wertzuweisungen Wertzuweisungen sind die zentralen elementaren Bausteine imperativer Programme. Die Wertzuweisungen verändern (i. a.) den momentanen Variablenzustand (Speicherzustand).

Imperative Programmierung Beschreiben, wie die Ergebnisse berechnet werden sollen. A.-Zustand {eingaben: [t][t][t][t]} z := anfangszustand; for i := 0 to n-1 do begin e := eingaben[i]; a := ausgabe(e); z := neuerZustand(e); ausgaben[i] := a; end; Register-maschine Anweisungen E.-Zustand {ausgaben: [Ooo][OOo][ooO][oOo]} Imperative Programmierung besteht darin, eine mehr oder weniger abstrakte Registermaschine (Maschine mit Speicherzellen) mit Hilfe von Anweisungen zu steuern.

Vorsicht: Seiteneffekte PROGRAM Demo; VAR d: boolean; w1, w2: integer; function f(n: int.): int.; BEGIN if d THEN f := 2*n ELSE f := n; d := not d; END; BEGIN d := true; w1 := f(1)+f(2); w2 := f(2)+f(1); END. {d: ; w1: ; w2: } d := true; {d: true; w1: ; w2: } w1 := f(1) + f(2) ; {d: true; w1: 4; w2: } w1 := f(2) + f(1) ; {d: true; w1: 4; w2: 5} 2 2 4 1 Seiteneffekt: Veränderung einer globalen Variablen Imperative Programmierung ist wegen der Möglichkeit, Seiteneffekte zu produzieren, recht fehleranfällig.

Funktionale Programmierung let rec simulator = function ((az, de, la), z, []) -> [] | ((az, de, la), z, e::r) -> la(z,e) :: simulator((az, de, la), de(z,e), r);; let transduktor = function ((az, de, la), w) -> simulator((az, de, la), az, w);; let ampel = (anfangszustandA, deltaA, lambdaA);; transduktor(ampel, [t;t;t;t;n;n]);; Programmierung mit Funkionsdeklarationen Die funktionale Programmierung arbeitet ohne Speichervariablen. Variablen kommen hier nur als Funktionsvariablen zur Übergabe von Funktionsargumenten vor. Seiteneffekte sind demnach in der funktionalen Programmierung nicht möglich. Das Verhalten einer Funktion wird vollständig durch die Funktionsdeklarationen festgelegt.

Funktionale Programmierung Beschreiben, was (welche funkt. Zusammenhänge) gelten soll. A.-Term transduktor(ampel,[t;t;t]);; ... let rec simulator = function ((az,de,la),z,[]) ->[]| ((az,de,la),z,e::r)->... Reduktions-maschine Deklarationen #- : ausgabeA list = [Ooo; OOo; ooO] E.-Term Funktionale Programmierung besteht darin, die strukturellen Zusammenhänge der Miniwelt mit Hilfe von Funktionen zu beschreiben.

Fazit Funktionale Programmierung erfolgt auf einem höheren Abstraktionsniveau: keine Anweisungen an eine Maschine, sondern Beschreibung funktionaler Zusammenhänge. Konsequenzen: - Funktionale Programme sind kurz. - Funktionale Programme sind leicht zu verstehen. - Funktionale Programmierung ist wenig fehleranfällig. - Funktionale Programmierung eignet sich zum „Prototyping“. Prototyp eines Automatensimulationsprogramms: let rec simulator = function ((az, de, la), z, []) -> [] | ((az, de, la), z, e::r) -> la(z,e) :: simulator((az, de, la), de(z,e), r);; let transduktor = function ((az, de, la), w) -> simulator((az, de, la), az, w);;

Literaturhinweise [Becker 99] K. Becker: Funktionale Programmierung. Materialien zum Lehrplan Informatik. LMZ 1999. (http://informatikag.bildung-rp.de/html/funktprog.html) [Becker 00] K. Becker: Problemlösen mit dem Computeralgebrasystem Derive - informatisch betrachtet. (http://informatikag.bildung-rp.de/html/derive.html) [Fischbacher 97] T. Fischbacher: Funktionale Programmierung. In: LOG IN 17 (1997) Heft 3 / 4, S. 24-26. [ISB 97] Staatliches Institut für Schulpädagogik und Bildungsforschung München (Hrsg.): Funktionales Programmieren in Gofer. Baustein zur Didaktik der Informatik. München, 1997. [Puhlmann 98] H. Puhlmann: Funktionales Programmieren - Eine organische Verbindung von Informatikunterricht und Mathematik. In: LOG IN 18 (1998) Heft 2, S. 46-50. [Schwill 93] A. Schwill: Funktionale Programmierung mit Caml. In: LOG IN 13 (1993) Heft 4, S. 20-30. [MacLennan ??] B.J. MacLennan: Functional Programming: Addison-Wesley ??. [Wagenknecht 94] Christian Wagenknecht: Rekursion. Ein didaktischer Zugang mit Funktionen. Bonn: Dümmlers Verlag 1994. [Wolff von Gudenberg 96] J. Wolff. von Gudenberg: Algorithmen, Datenstrukturen, Funktionale Programmierung. Eine praktische Einführung mit Caml Light. Bonn: Addison-Wesley 1996.