Regular Expression Types Moritz Fuchs. Agenda Wiederholung Reguläre Ausdrücke Regular Expression Types Beispiele.

Präsentation zum Thema: "Regular Expression Types Moritz Fuchs. Agenda Wiederholung Reguläre Ausdrücke Regular Expression Types Beispiele."—  Präsentation transkript:

1 Regular Expression Types Moritz Fuchs

2 Agenda Wiederholung Reguläre Ausdrücke Regular Expression Types Beispiele

3 Reguläre Ausdrücke

4 Beschreiben die regulären Sprachen Kompakt Ausdrucksstark Eindeutiger minimaler DFA!

5 Regeln Basiswörter Aneinanderreihung Alternative Kleene-Stern Nützliche Makros

6 Grundlagen ε ist das leere Wort ∑ ist das Zielalphabet A-Z 0,1 String,Int,Float,...

7 Basiswörter a ∈ ∑ ∪ {ε} Beispiele: α = t α = ε

8 Aneinanderreihung α, β seien reguläre Ausdrücke Dann ist γ = αβ ein regulärer Ausdruck Bedeutung: Erst α dann β

9 Alternative α,β reguläre Ausdrücke Dann ist γ = α ∣ β ein regulärer Ausdruck Bedeutung: Einer der Ausdrücke muss erfüllt sein

10 Kleene-Stern Sei α ein regulärer Ausdruck Dann ist γ = α* ein regulärer Ausdruck Bedeutung: 0 oder mehr

11 ? - Makro α wieder regulärer Ausdruck γ = α? steht für α ∣ ε Bedeutung: Optionalität

12 + - Makro α wieder regulärer Ausdruck γ = α+ steht für αα* Bedeutung: „Einmal oder mehr“

13 Beispiel - Adressbuch

14 Regular Expression Types

15 Reguläre Ausdrücke in Typsystemen Subtyping Rekursive Definitionen Polymorphe Funktionen Vor- und Nachteile

16 Beispiel RET type Addrbook = addrbook[Person*] type Person = person[Name,Email*,Tel?] type Name = name[String] type Email = Email[String] type Tel = tel[String]

17 Beispiel ohne RET type Addrbook = addrbook[SomePersons] type SomePersons = Person,SomePersons | () type Person = person[Name,SomeEmails,OptionalTel] type SomeEmails = Email,SomeEmails | () type OptionalTel = Tel | () type Name = name[String] type Email = Email[String] type Tel = tel[String]

18 Subtyping Inklusionsbeziehnung zwischen regulären Ausdrücken Inklusionsbeziehung zwischen Tree Automata Potentiell sehr teuer (EXPTIME-vollständig)

19 Subtyping Beispiel type Addrbook = addrbook[Person*] type Person = person[Name,Email*,Tel?] person[Name,Email*,Tel?] <: person[Name,Email*,Tel*]

20 Rekursive Definitionen type betterAddrbook = Eintrag* type Eintrag = name[String], betterAddrbook | person[Name,Email*,Tel?], (important[] | unimportant[])

21 Rekursive Definitionen Nicht alle Arten erlaubt Sonst wäre Inklusion nicht mehr entscheidbar Ausdrücke müssen,wohlgeformt‘ sein

22 Wohlgeformtheit type X = a[],Y type Y = b[],X | ()

23 Subtyping bei Rekursiven Definitionen type importantAddrbook = Eintrag* type Eintrag = name[String], importantAddrbook | person[Name,Email*,Tel?], important[] importantAddrbook <: betterAddrbook

24 Polymorphe Funktionen filter (a | b)* -> b* filter (x :: b, xs :: (a | b)* ) = ( x, filter xs ) filter (x :: a, xs :: (a | b)* ) = filter xs filter () = ()

25 Polymorphe Funktionen Problem: Mehrdeutige Instanzierungen: filter (C | C)* -> C* filter (x :: C, xs :: (C | C)* ) = ( x, filter xs ) filter (x :: C, xs :: (C | C)* ) = filter xs filter () = () Alle akzeptieren? Alle ablehnen?

26 Polymorphe Funktionen Lösung: Mehrdeutige Instanzierungen werden abgelehnt! Potentiell mehrdeutige Instanzierungen werden trotzdem akzeptiert

27 Vor- und Nachteile flexibel kompakt Potentiell langsam durch Inklusionsprüfung für Subtyping

28 Implementierungen XDuce (Beispiel 1) XHaskell (Beispiel 2) CDuce...

29 XDuce

30 Optimiert für XML-Verarbeitung Erste Spracherweiterung für Regular Expression Types

31 Subtagging Zusätzlich zum Subtyping manuelle Subtypen: subtag pizza <: essen subtag nudeln <: essen

32 ~ Für jedes label l gilt: subtag l <: ~ Nützlicher Typ Any: type Any = (~[Any] | String | Int | Float)*

33 FUN!

34 Beispiel 1 - XDuce XML-Datenbankerweiterung

35 Ausgangssituation Moritz Fuchs moritz.fuchs@gmail.com 987654321 Max Mustermann max@mustermann.de il> <Email madMax@mustermann.de n>

36 Ausgangssituation type Addrbook = addrbook[Person*] type Person = person[Name,Email*,Tel?] type Addrbook = addrbook[Person*] type Person = person[Name,Email*,Tel*]

37 2. Datenbank type Addrbook2 = addrbook[Person2*] type Person2 = person[Name,Email*,Addr]

38 Integration Erste Idee: type Addrbook3 = addrbook[Person1*,Person2*] Nachteil: 2 Schleifen nötig für die Verarbeitung Lösung: Umformung des regulären Ausdrucks

39 Integration person[Name,Email*,Tel*] | person[Name,Email*,Addr] Idee: (Person1*, Person2*) ist Subtyp von (Person1 | Person2)* = person[(Name,Email*,Tel*) | (Name,Email*,Addr)] = person[(Name,Email*, (Tel* | Addr)]

40 Lösung type Addrbook3 = addrbook[Person3*] type Person3 = person[Name,Email*,(Tel* | Addr)]

41 Beispiel 2.1 - XHaskell Von einem Adressbuch zu einem Telefonbuch - in 8 Zeilen

42 Ausgangssituation data Person = Person Name (Email*) (Tel*) data Name = Name String data Tel = Tel String data Email = Email String data Eintrag = Eintrag (Name,Tel+) data Buch a= Buch a* type AddrBuch = Buch Person type Telefonbuch = Buch Eintrag

43 Schritt 1- Person zu Eintrag p2E :: Person -> Eintrag? p2E (Person (n:: Name)(es :: Email*) (t::Tel+)) = Eintrag (n,t) p2E (Person (n:: Name) (es :: Email*) (t::())) = ()

44 Schritt 2- mapStar mapStar :: (a -> b) -> a* -> b* mapStar f (x :: ()) = x mapStar f (x::a, xs::a*) = (f x, mapStar f xs)

45 Schritt 3- Adressbuch zu Telefonbuch ab2tb :: Addrbuch -> Telefonbuch ab2tb (Buch (x :: Person*)) = Buch (mapStar pToE x)

46 Beispiel 2.2 - XHaskell λ-Funktionen

47 Ausgangssituation data Female = F data Male = M members :: (Female | Male)* Ziel: (Female*, Male*)

48 fold :: (a -> b -> a) -> a -> b* -> a fold f x (y :: ()) = x fold f x ((y::b)(ys::b*)) = fold f (f x y) ys Schritt 1- fold

49 transform :: (a | b)* -> (a*,b*) transform xs = fold (\x->\y -> case y of (z::a) -> (z,x) (z::b) -> (x,z)) () xs Schritt 2- transformation transform members

50 Fragen?