3.1.4 Benutzerdefinierte Datentypen

Transkript

1 3.1.4 Benutzerdefinierte Datentypen Übersicht: Vereinbarung von Typbezeichnern Deklaration neuer Typen Summentypen Rekursive Datentypen Fast alle modernen Spezifikations- und Programmiersprachen gestatten es dem Benutzer, neue Typen zu definieren. Vereinbarung von Typbezeichnern ML erlaubt es, Bezeichner für Typen zu deklarieren (vgl. Folie 105). Dabei wird kein neuer Typ definiert, sondern nur ein Typ an einen Bezeichner gebunden. 08/06/08 58

2 Beispiele: (Typvereinbarungen) type intpaar = int * int type charlist = char list type adresse = string * string* string * int type telefonbuch = ( adresse * string list ) list type intnachint = int! int ; val fakultaet : intnachint = fac ; Typvereinbarungen sind nur Abkürzungen. Zwei unterschiedliche Bezeichner können den gleichen Typ bezeichnen; z.b.: - type inttripel = int * int * int; type inttripel = int * int * int - type date = int * int * int; type date = int * int * int - fun kalenderwoche (d:date): int =... ; val kalenderwoche = fn : date -> int - kalenderwoche (192,45,111111); 08/06/08 59

3 Deklaration neuer Typen Neue Typen werden in ML mit dem datatype-konstrukt definiert, das im Folgenden schrittweise erläutert wird. Definition eines neuen Typs und Konstruktors: datatype <Typbezeichner> = <Konstruktorbezeichner> of <TypAusdruck> Die obige Datatypdeklaration definiert: - einen neuen Typ und bindet ihn an <Typbezeichner> - eine Konstruktorfunktion, die Werte des durch den Typausdruck beschriebenen Typs in den neuen Typ einbettet. Die Konstruktorfunktion ist injektiv. 08/06/08 60

4 Beispiel: (Definition von Typ und Konstruktor) datatype person = Student of string * string * int * int definiert den neuen Typ person und den Konstruktor Student: string*string*int*int -> person Wir definieren die Selektorfunktionen: - fun vorname (Student(v,n,g,m)) = v ; val vorname = fn : person -> string - fun name (Student(v,n,g,m)) = n ; val name = fn : person -> string - fun geburtsdatum (Student(v,n,g,m)) = g ; val geburtsdatum = fn : person -> int - fun matriknr (Student(v,n,g,m)) = m ; val matriknr = fn : person -> int 08/06/08 61

5 Jede Datentypdeklaration definiert einen neuen Typ, d.h. insbesondere: - Werte vom Argumentbereich des Konstruktors sind inkompatibel mit dem neuen Typ; - Werte strukturgleicher benutzerdefinierter Typen sind inkompatibel. Beispiele: (Typkompatibilität) 1. Der Typ person ist inkompatibel mit dem Typ string*string*int*int, insbesondere ist vorname ( Niels, Bohr, , 221) nicht typkorrekt. 2. Der Typ person ist inkompatibel mit dem strukturgleichen Typ adresse datatype adresse = WohnAdresse of string * string * int * int Insbesondere ist name (WohnAdresse( Pfaffenbergstraße, nicht typkorrekt. Kaiserslautern, 27, ) ) 08/06/08 62

6 Bemerkung: Den Konstruktor kann man sich als eine Markierung der Werte seines Argumentbereichs vorstellen. Dabei werden Werte mit unterschiedlicher Markierung als verschieden betrachtet. Summentypen Ein Summentyp stellt die disjunkte Vereinigung der Elemente anderen Typen zu einem neuen Typ dar. Die meisten modernen Programmiersprachen unterstützen die Deklaration von Summentypen. Summentypen in ML: Bei einer Datentypdeklaration kann man verschiedene Alternativen angeben: datatype <Typbezeichner> = <Konstruktorbezeichner1> of <TypAusdruck1>... <KonstruktorbezeichnerN> of <TypAusdruckN> 08/06/08 63

7 Beispiele: (Summentypen) 1. Ein anderer Datentyp zur Behandlung von Personen: datatype person2 = Student of string*string*int*int Mitarbeiter of string*string*int*int Professor of string*string*int*int*string 2. Eine benutzerdefinierte Datenstruktur für Zahlen: - datatype number = Intn of int Realn of real - fun isint (Intn m) = true isint (Realn r) = false ; val isint = fn : number -> bool - fun isreal (Intn m) = false isreal (Realn r) = true ; val isreal = fn : number -> bool - fun neg (Intn m) = Intn (~m) neg (Realn r) = Realn (~r); val neg = fn : number -> number 08/06/08 64

8 - fun plus (Intn m,intn n) = Intn (m+n) plus (Intn m,realn r) = Realn((real m) +r) plus (Realn r,intn m) = Realn(r+(real m)) plus (Realn r,realn q)= Realn(r+q); val plus = fn : number * number -> number Begriffsklärung: Konstruktorfunktionen oder Konstruktoren liefern Werte des neu definierten Datentyps. Sie können in Mustern verwendet werden (z.b.: Student, Intn). Diskriminatorfunktionen oder Diskriminatoren prüfen, ob der Wert eines benutzerdefinierten Datentyps zu einer bestimmten Alternative gehört (Beispiel: isint). Selektorfunktionen oder Selektoren liefern Komponenten von Werten des definierten Datentyps (z.b.: vorname, name,...). Bemerkung: In funktionalen Sprachen kann man meist auf Selektorfunktionen verzichten. Man wendet stattdessen Pattern. 08/06/08 65

9 Weitere Formen des datatype-konstrukts: Das datatype-konstrukt kann auch verwendet werden, um Aufzählungstypen zu definieren. Dabei wird in den Alternativen der Teil beginnend mit dem Schlüsselwort of weggelassen. Die Wertemenge eines Aufzählungstyps ist eine endliche Menge (von Namen). Beispiele: (Aufzählungstypen) - datatype wochentag = Montag Dienstag Mittwoch Donnerstag Freitag Samstag Sonntag ; - fun istmittwoch Mittwoch = true istmittwoch w = false ; Oder knapper: - fun istmittwoch w = (w=mittwoch) ; 08/06/08 66

10 Beide Formen der Datentypdeklaration können kombiniert werden; z.b.: - datatype intbottom = Bottom Some of int Datentypdeklarationen lassen sich parametrisieren. Die Typparameter werden dabei vor den vereinbarten Typbezeichner gestellt: - datatype a bottom = Bottom Some of a ML sieht dafür standardmäßig den folgenden Typ vor: - datatype a option = NONE SOME of a Zur Erweiterung von Summentypen Im Gegensatz zur objektorientierten Programmierung (vgl. Kapitel 5) lassen sich die Summentypen in der funktionalen Programmierung meist nicht erweitern, d.h. einem definierten Datentyp können im Nachhinein keine Alternativen hinzugefügt werden. 08/06/08 67

11 Beispiel: (Erweiterung von Summentypen) Den Datentyp person2: datatype person2 = Student of string*string*int*int Mitarbeiter of string*string*int*int Professor of string*string*int*int*string hätte man aus person durch Hinzufügen der Alternativen für Mitarbeiter und Professoren gewinnen können. Bemerkung: Die Möglichkeit, einen Datentypen T nachträglich erweitern zu können, bringt zwei Vorteile für die Wiederverwendung mit sich: 1. Der Programmieraufwand wird reduziert. 2. Programme, die für T entwickelt wurden, können teilweise weiter benutzt werden. In ML müssen Erweiterungen im Allg. durch neue Summentypen realisiert werden. 08/06/08 68

12 Beispiel: Ein Datentyp dt : datatype dt = Constr1 of t1 Constr2 of t2 Constr3 of t3 Constr4 of t4 soll eine fünfte Alternative bekommen. Statt alle existierenden Programme auf fünf Alternativen umzustellen, kann man mit dtneu arbeiten: datatype dtneu = Constr0 of dt Constr5 of t5 Nachteil: Die Programme müssen auf dtneu angepasst werden. Bemerkung: Der Datentyp exn ist in ML erweiterbar. Jede Ausnahme-Vereinbarung fügt eine Alternative hinzu. 08/06/08 69

13 Rekursive Datentypen Von großer Bedeutung in der Programmierung sind rekursive Datentypen. Definition: (rekursive Datentypdeklaration) Eine Datentypdeklaration heißt direkt rekursiv, wenn der definierte Typ in einer der Alternativen der Datentypdeklaration vorkommt. Wie bei Funktionen gibt es auch verschränkt rekursive Datentypdeklarationen. Eine Datentypdeklaration heißt rekursiv, wenn sie direkt rekursiv ist oder Element einer Menge verschränkt rekursiver Datentypdeklarationen ist. Begriffsklärung: (rekursiver Datentyp) Ein Datentyp heißt rekursiv, wenn er mit einer rekursiven Datentypdeklaration definiert wurde. 08/06/08 70

14 Beispiele: (Listendatentypen) 1. Ein Datentyp für Integer-Listen: - datatype intlist = nil Cons of int * intlist ; 2. Ein Datentyp für homogene Listen mit Elementen von beliebigem Typ: - datatype a list = Vorsicht: nil Cons of a * a list Diese Deklaration verdeckt den vordefinierten Datentyp a list. 3. Der vordefinierte Datentyp für homogene Listen mit Elementen von beliebigem Typ: - datatype a list = nil :: of a * a list 08/06/08 71

15 Baumartige Datenstrukturen: Ottmann, Widmayer: Bäume gehören zu den wichtigsten in der Informatik auftretenden Datenstrukturen. A B D E C F G Begriffsklärung: (zu Bäumen) In einem endlich verzweigten Baum hat jeder Knoten endlich viele Kinder. Üblicherweise sagt man, die Kinder sind von links nach rechts geordnet.. Einen Knoten ohne Kinder nennt man Blatt, einen Knoten mit Kindern einen inneren Knoten oder Zweig. Den Knoten ohne Elter nennt man Wurzel. H 08/06/08 72

16 Ein Baum heißt markiert, wenn jeder Knoten k eine Markierung m(k) besitzt. In einem Binärbaum ist jeder Knoten entweder ein Blatt, oder er hat genau zwei Kinder. Zu jedem Knoten gehört ein Unterbaum. Datentyp für markierte Binärbaume: - datatype intbbaum = Blatt of int Zweig of int * intbbaum * intbbaum ; - val einbaum = Zweig (7, Zweig(3,(Blatt 2),(Blatt 4)), (Blatt 5)); - fun m (Blatt n) = n m (Zweig (n,lk,rk)) = n ; Ein mit ganzen Zahlen markierter Binärbaum heißt sortiert, wenn für alle Knoten k gilt: - Die Markierungen der linken Nachkommen von k sind kleiner als m(k). - Die Markierungen der rechten Nachkommen von k sind größer als m(k). 08/06/08 73

17 Aufgabe: Prüfe, ob ein Baum vom Typ intbbaum sortiert ist. Idee: Berechne zu jedem Unterbaum die minimale und maximale Markierung und prüfe rekursiv die Sortiertheitseigenschaft für alle Knoten/Unterbäume. fun maxmark (Blatt n) = n maxmark (Zweig (n,l,r)) = Int.max(n,Int.max(maxmark l, maxmark r)) fun minmark (Blatt n) = n minmark (Zweig (n,l,r)) = Int.min(n,Int.min(minmark l, minmark r)) fun istsortiert (Blatt n) = true istsortiert (Zweig (n,l,r)) = istsortiert l andalso istsortiert r andalso (maxmark l)<n andalso n<(minmark r) istsortiert einbaum 08/06/08 74

18 Wenig effiziente Lösung!! Besser ist es, die Berechnung von Minima und Maxima mit der Sortiertheitsprüfung zu verschränken. Idee: Entwickle eine Einbettung, die für sortierte Bäume auch Minimum und Maximum liefert. fun istsorteinbett (Blatt n) = (true,n,n) istsorteinbett (Zweig (n,l,r)) = let val (lerg,lmn,lmx) = istsorteinbett l val (rerg,rmn,rmx) = istsorteinbett r in ( lerg andalso rerg andalso end ; lmx<n andalso n<rmn, lmn, rmx ) fun istsortiert b = #1 (istsorteinbett b) Parametrische markierte Binärbaumtypen: 1. Alle Markierungen sind vom gleichen Typ: datatype a bbaum = Blatt of a Zweig of a * a bbaum * a bbaum 08/06/08 75

19 2. Blatt- und Zweigmarkierungen sind möglicherweise von unterschiedlichen Typen: datatype ( a, b) bbaum = Blatt of a Zweig of b * ( a, b) bbaum * ( a, b) bbaum Bäume mit variabler Kinderzahl: Bäume mit variabler Kinderzahl lassen sich realisieren: - durch mehrere Alternativen für Zweige (begrenzte Anzahl von Kindern) - durch Listen von Unterbäumen: datatype a baum = Kn of a * ( a baum list) fun zaehlekn (Kn (_,xs)) = Beachte: foldr op+ 1 (map zaehlekn xs) Der Rekursionsanfang ergibt sich durch Knoten mit leerer Unterbaumliste. 08/06/08 76

20 Bäume mit variabler Kinderzahl lassen sich z.b. zur Repräsentation von Syntaxbäumen verwenden, indem das Terminal- bzw. Nichtterminalsymbol als Markierung verwendet wird. Besser ist es allerdings, die Information über die Symbole mittels Konstruktoren auszudrücken. Dadurch gewinnt man an Typsicherheit (vgl. nächstes Beispiel). Verschränkte Datentypdeklarationen: Genau wie Funktionsdeklarationen werden verschränkt rekursive Datentypdeklarationen mit dem Schlüsselwort and verbunden: datatype <Typbezeichner1> = <Konstruktorbezeichner1_1> of <TypAusdruck1_1>... <Konstruktorbezeichner1_N> of <TypAusdruck1_N> and... and <TypbezeichnerM> = <KonstruktorbezeichnerM_1> of <TypAusdruckM_1>... <KonstruktorbezeichnerM_K> of <TypAusdruckM_K> 08/06/08 77

21 Beispiel: (verschränkte Datentypen) Der abstrakte Syntaxbaum eines Programms repräsentiert die Programmstruktur unter Verzicht auf Schlüsselworte und Trennzeichen. Rekursive Datentypen eignen sich sehr gut zur Beschreibung von abstrakter Syntax. Als Beispiel betrachten wir die abstrakte Syntax von Femto: datatype programm = Prog of wertdekl list * ausdruck and wertdekl = Dekl of string * ausdruck and ausdruck = Bzn of string Zahl of int Add of ausdruck * ausdruck Mul of ausdruck * ausdruck Das Programm val a = 73; ( a + 12 ) ; Wird durch folgenden Baum repräsentiert: Prog ( [Dekl ( a,zahl 73)], Add (Bzn a,zahl 12) ) Die Baumrepräsentation eignet sich besser als die Zeichenreihenrepräsentation zur weiteren Verarbeitung von Programmen. 08/06/08 78

22 Unendliche Datenobjekte: Eine nicht-leere Liste ist ein Wert, zu dem man sich das erste Element und eine Liste als Rest geben lassen kann. Hat die endliche Liste xl die Länge n>0, dann hat (tl xl) die Länge n-1. Eine unendliche Liste besitzt keine natürlichzahlige Länge und wird durch Anwendung von tl nicht kürzer. Unendliche Listen, häufig als Ströme (engl. stream) bezeichnet, sind die einfachsten unendlichen Daten- Objekte. In ML lassen sich unendliche Listen mit folgender Datenstruktur realisieren: datatype a stream = Nil Cons of a * ( unit -> a stream ) fun hd (Cons ( x, xf )) = x hd Nil = raise Empty fun tl (Cons ( x, xf )) = xf () tl Nil = raise Empty 08/06/08 79

23 Beispiel: (unendliche Liste) Liste aller (positiven) Dualzahlen dargestellt als Zeichenreichen: - fun incr (#"O"::xs) = #"L"::xs incr (#"L"::xs) = #"O":: incr xs incr [ ] = [ #"L" ] ; val incr = fn : char list -> char list - fun incrstr s = implode (rev (incr (rev (explode s)))); val incrstr = fn : string -> string - fun dualz_ab s = Cons (s, fn x=> dualz_ab (incrstr s)); val dualz_ab = fn: string -> string stream - val dl = dualz_ab "O" ; val dl = Cons ("O",fn) : string stream - hd dl; val it = "O" : string - val dl = tl dl; val dl = Cons ("L",fn) : string stream - val dl = tl dl; val dl = Cons ("LO",fn) : string stream 08/06/08 80

24 3.1.5 Felder/Arrays in ML Felder sind ein imperatives Sprachelement. Wir betrachten sie vor allem in Kapitel 4 und 5. Hier soll gezeigt werden, - wie imperative und funktionale Sprachkonstrukte zusammenwirken - wie Listen and Felder zusammenhängen Begriffsklärung: (Variable) Eine Speichervariable oder einfach nur Variable ist ein Speicher/Behälter für Werte. Charakteristische Operationen auf einer Variablen v: - Zuweisen eines Werts w an v; - Lesen des Wertes, den v enthält/speichert/hat. Der Zustand einer Variablen v ist undefiniert, wenn ihr noch kein Wert zugewiesen wurde; andernfalls ist der Zustand von v durch den gespeicherten Wert charakterisiert. Variablen stellen wir graphisch durch Rechtecke dar: v: true v1: 7 v enthält/speichert den Wert true v1 enthält/speichert den Wert 7 08/06/08 81