Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

Funktionale Programmierung mit Caml Klaus Becker 2004.

Ähnliche Präsentationen


Präsentation zum Thema: "Funktionale Programmierung mit Caml Klaus Becker 2004."—  Präsentation transkript:

1 Funktionale Programmierung mit Caml Klaus Becker 2004

2 KB Funktionale Programmierung 2 Programmieren mit Funktionen 1 gu Ok! akzeptor

3 KB Funktionale Programmierung 3 Teil 1 Funktionen als Programme

4 KB Funktionale Programmierung 4 Die Welt der Automaten 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). 1 gu 00 1

5 KB Funktionale Programmierung 5 Eine Automatenbeschreibung Zustandsmenge: Z = {g, u} Anfangszustand:z a = g Endzustände:z E = {g} Eingabemenge: E = {0, 1} Überführungsfunktion: : (g, 0) g : (g, 1) u : (u, 0) u : (u, 1) g 1 gu 00 1

6 KB Funktionale Programmierung 6 Funktionale Modellierung Zustandsmenge: Z = {g, u} Eingabemenge: E = {0, 1} Anfangszustand:z a = g Endzustände:z E = {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 ;; 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 ;;

7 KB Funktionale Programmierung 7 Funktionale Modellierung 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 ;; 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 ;; deltaP: (g, e1) uendzustandP: g trueanfangszustandP zustandeingabezustandboolzustand gu gugue0e1 truefalse

8 KB Funktionale Programmierung 8 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 ;; 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).

9 KB Funktionale Programmierung 9 Auswertung von Deklarationen 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 ;; 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 ;; #Type zustandP defined. #Type eingabeP defined. #anfangszustandP : zustandP = g #endzustandP : zustandP -> bool = #deltaP : zustandP * eingabeP -> zustandP = #Type zustandP defined. #Type eingabeP defined. #anfangszustandP : zustandP = g #endzustandP : zustandP -> bool = #deltaP : zustandP * eingabeP -> zustandP = Auswertung durch Caml Benutzereingabe

10 KB Funktionale Programmierung 10 Signaturanalyse Benutzereingabe: type zustandP = g | u;; type eingabeP = e0 | e1;;... let deltaP = function (g, e0) -> g | (g, e1) -> u | (u, e0) -> u | (u, e1) -> g ;; Benutzereingabe: type zustandP = g | u;; type eingabeP = e0 | e1;;... let deltaP = function (g, e0) -> g | (g, e1) -> u | (u, e0) -> u | (u, e1) -> g ;; Auswertung: #deltaP : zustandP * eingabeP -> zustandP = Auswertung: #deltaP : zustandP * eingabeP -> zustandP = 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. Funktionsdeklaration Signatur der Funktion

11 KB Funktionale Programmierung 11 Funktionsanwendung 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 ;; 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 ;; Auswertung:... #deltaP : zustandP * eingabeP -> zustandP = #deltaP(u, e0);; - : zustandP = u Auswertung:... #deltaP : zustandP * eingabeP -> zustandP = #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);; Aktuelle Benutzereingabe: deltaP(u, e0);;

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

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

14 KB Funktionale Programmierung 14 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.

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

16 KB Funktionale Programmierung 16 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 |...

17 KB Funktionale Programmierung 17 Teil 2 Kontrollstrukturen

18 KB Funktionale Programmierung 18 Zielsetzung 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. 1 gu Ok!

19 KB Funktionale Programmierung 19 Listen Eine Liste in Caml besteht aus einer beliebigen, aber endlichen Anzahl von Elementen, die alle den gleichen Typ haben. 1 gu 00 1 [0; 0; 0; 1; 1; 0; 1; 1] true

20 KB Funktionale Programmierung 20 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]

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

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

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

24 KB Funktionale Programmierung 24 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.

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

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

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

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

29 KB Funktionale Programmierung 29 Lösungsvorschlag... (* 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]);;... (* 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]);; #simulatorA : zustandA * eingabeA list -> ausgabeA list = #- : ausgabeA list = [Ooo; OOo; ooO; ooO; ooo; oOo] #simulatorA : zustandA * eingabeA list -> ausgabeA list = #- : ausgabeA list = [Ooo; OOo; ooO; ooO; ooo; oOo]

30 KB Funktionale Programmierung 30 Teil 3 Datenstrukturen

31 KB Funktionale Programmierung 31 Zielsetzung Es soll ein universelles Akzeptor-System entwickelt werden, mit dem eine Folge von Eingaben mit einem beliebig vorgegebenen Automaten verarbeiten werden kann Ok! 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 ;;

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

33 KB Funktionale Programmierung 33 Zustand nach der Verarbeitung der Eingaben Automatenbeschreibung simulator Bsp.: simulator((g, (g true, u false),...), g, [e0; e1; e1; e1]) u Eingabeliste Zustand Spezifikation: Automatenbeschreibung 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).

34 KB Funktionale Programmierung 34 Reduktionsregeln 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));; 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));; #simulator : ('a * 'b * ('c * 'd -> 'd)) * 'd * 'c list -> 'd = #akzeptor : ('a * ('a -> 'b) * ('c * 'a -> 'a)) * 'c list -> 'b = #simulator : ('a * 'b * ('c * 'd -> 'd)) * 'd * 'c list -> 'd = #akzeptor : ('a * ('a -> 'b) * ('c * 'a -> 'a)) * 'c list -> 'b =

35 KB Funktionale Programmierung 35 Test 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);; 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);; #akzeptor(automatP, wortP);; - : bool = false #akzeptor(automatP, wortP);; - : bool = false

36 KB Funktionale Programmierung 36 Datenstrukturen let rec simulator = function ((az,ez,de), z, []) -> z | ((az,ez,de), z, e::r) -> simulator(...);; 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. 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. Funktion Liste Tupel

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

38 KB Funktionale Programmierung 38 Lösungsvorschlag... (* 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]);;... (* 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]);; #simulator : ('a * ('b * 'c -> 'b) * ('b * 'c -> 'd)) * 'b * 'c list -> 'd list = #transduktor : ('a * ('a * 'b -> 'a) * ('a * 'b -> 'c)) * 'b list -> 'c list = #ampel : zustandA * (zustandA * eingabeA -> zustandA) * (zustandA * eingabeA -> ausgabeA) = ge,, #- : ausgabeA list = [Ooo; OOo; ooO; oOo; ooo; oOo] #simulator : ('a * ('b * 'c -> 'b) * ('b * 'c -> 'd)) * 'b * 'c list -> 'd list = #transduktor : ('a * ('a * 'b -> 'a) * ('a * 'b -> 'c)) * 'b list -> 'c list = #ampel : zustandA * (zustandA * eingabeA -> zustandA) * (zustandA * eingabeA -> ausgabeA) = ge,, #- : ausgabeA list = [Ooo; OOo; ooO; oOo; ooo; oOo]

39 KB Funktionale Programmierung 39 Teil 4 Deklarative Programmierung

40 KB Funktionale Programmierung 40 Programmierstile 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]);; 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]);; 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

41 KB Funktionale Programmierung 41 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).

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

43 KB Funktionale Programmierung 43 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. 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} {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} Seiteneffekt: Veränderung einer globalen Variablen Imperative Programmierung ist wegen der Möglichkeit, Seiteneffekte zu produzieren, recht fehleranfällig.

44 KB Funktionale Programmierung 44 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]);; 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]);; Funktionale Programmierung 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.

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

46 KB Funktionale Programmierung 46 Fazit Prototyp eines Automatensimulationsprogramms: 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. 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 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);;

47 KB Funktionale Programmierung 47 Literaturhinweise [Becker 99] K. Becker: Funktionale Programmierung. Materialien zum Lehrplan Informatik. LMZ (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 [ISB 97] Staatliches Institut für Schulpädagogik und Bildungsforschung München (Hrsg.): Funktionales Programmieren in Gofer. Baustein zur Didaktik der Informatik. München, [Puhlmann 98] H. Puhlmann: Funktionales Programmieren - Eine organische Verbindung von Informatikunterricht und Mathematik. In: LOG IN 18 (1998) Heft 2, S [Schwill 93] A. Schwill: Funktionale Programmierung mit Caml. In: LOG IN 13 (1993) Heft 4, S [MacLennan ??] B.J. MacLennan: Functional Programming: Addison-Wesley ??. [Wagenknecht 94] Christian Wagenknecht: Rekursion. Ein didaktischer Zugang mit Funktionen. Bonn: Dümmlers Verlag [Wolff von Gudenberg 96] J. Wolff. von Gudenberg: Algorithmen, Datenstrukturen, Funktionale Programmierung. Eine praktische Einführung mit Caml Light. Bonn: Addison-Wesley 1996.


Herunterladen ppt "Funktionale Programmierung mit Caml Klaus Becker 2004."

Ähnliche Präsentationen


Google-Anzeigen