Programmieren in Haskell

Transkript

1 beschreibungen Universität Bielefeld AG Praktische Informatik October 21, 2014

2 der funktionalen Programmierung gibt es allen Programmiersprachen, aber der funktionalen Programmierung werden sie besonders viel benutzt. Dafür gibt es een polymorphen Datentyp für aus Elementen von beliebigem, aber gleichem Typ viele vordefierte Funktionen auf ee spezielle Notation für, beschreibungen ähnlich der mathematischen Mengen-Notation beschreibungen

3 Der polymorphe -Typ [a] Notation: [1,2,3,4] geschönte Notation 1:2:3:4:[] Standard-Notation mit Konstruktoren beschreibungen

4 Der polymorphe -Typ [a] Notation: [1,2,3,4] geschönte Notation 1:2:3:4:[] Standard-Notation mit Konstruktoren (:) :: a -> [a] -> [a] Cons [] :: [a] Nil beschreibungen

5 Der polymorphe -Typ [a] Notation: [1,2,3,4] geschönte Notation 1:2:3:4:[] Standard-Notation mit Konstruktoren (:) :: a -> [a] -> [a] Cons [] :: [a] Nil [1..10] Typ-Notation: [a], [Int] usw. beschreibungen

6 Der polymorphe -Typ [a] Notation: [1,2,3,4] geschönte Notation 1:2:3:4:[] Standard-Notation mit Konstruktoren (:) :: a -> [a] -> [a] Cons [] :: [a] Nil [1..10] Typ-Notation: [a], [Int] usw. beschreibungen Ma> 1:2:3:4:[] [1,2,3,4]

7 Der polymorphe -Typ [a] Notation: [1,2,3,4] geschönte Notation 1:2:3:4:[] Standard-Notation mit Konstruktoren (:) :: a -> [a] -> [a] Cons [] :: [a] Nil [1..10] Typ-Notation: [a], [Int] usw. beschreibungen Ma> 1:2:3:4:[] [1,2,3,4] Example 1 > length :: [a] -> Int 2 > length [] = 0 3 > length (a:as) = 1 + length as

8 beschreibungen für Zahlenfolgen Besonders komfortable Notation gibt es für Zahlenfolgen: 1 l1 = [1,2,3,4,5,6,7,8,9,10] 2 l2 = [ ] 3 l3 = [1..] 4 l4 = [1,5..42] 5 l5 = [1,5..] 6 l6 = [10,8.. 1] Aufsteigende und absteigende Zahlenfolgen; die Differenz der beiden ersten Zahlen gibt die Schrittweite und Richtung an,.. bedeutet Fortsetzung, bis zum Endwert wenn angegeben, sonst unendlich. beschreibungen

9 Arithmetic Sequences Syntaktischer Zucker für [expr1..] beschreibungen

10 Arithmetic Sequences Syntaktischer Zucker für [expr1..] [expr1..expr2] beschreibungen

11 Arithmetic Sequences Syntaktischer Zucker für [expr1..] [expr1..expr2] [expr1,expr2..] beschreibungen

12 Arithmetic Sequences Syntaktischer Zucker für [expr1..] [expr1..expr2] [expr1,expr2..] [expr1,expr2..expr3] beschreibungen

13 Arithmetic Sequences Syntaktischer Zucker für [expr1..] [expr1..expr2] [expr1,expr2..] [expr1,expr2..expr3] Example beschreibungen ghci> [1..5] [1,2,3,4,5] ghci> [1,3..10] [1,3,5,7,9] ghci> [2,4..10] [2,4,6,8,10] ghci> [1..] [1,2,3,...

14 Arithmetic Sequences Übersetzung: [expr1..] = enumfrom expr1 beschreibungen

15 Arithmetic Sequences Übersetzung: [expr1..] = enumfrom expr1 [expr1..expr2] = enumfromto expr1 expr2 beschreibungen

16 Arithmetic Sequences Übersetzung: [expr1..] = enumfrom expr1 [expr1..expr2] = enumfromto expr1 expr2 [expr1,expr2..] = enumfromthen expr1 expr2 beschreibungen

17 Arithmetic Sequences Übersetzung: [expr1..] = enumfrom expr1 [expr1..expr2] = enumfromto expr1 expr2 [expr1,expr2..] = enumfromthen expr1 expr2 beschreibungen [expr1,expr2..expr3] = enumfromthento expr1 expr2 expr3

18 Arithmetic Sequences Übersetzung: [expr1..] = enumfrom expr1 [expr1..expr2] = enumfromto expr1 expr2 [expr1,expr2..] = enumfromthen expr1 expr2 beschreibungen [expr1,expr2..expr3] = enumfromthento expr1 expr2 expr3 Voraussetzung: expr i haben den Gleichen Typ T Typ T gehört der Typklasse Enum an

19 beschreibungen beschreibungen sd der mathematischen Mengen-Notation nachempfunden. Beispiel: 1 sm = [x x <- " abraham ", x < i ] 2 pairs = [(a,b +1) a <- " aber ", b <- [1,2,3]] beschreibungen, 3 evenodd = [(a,b,a+b) a <- [1..10], b <- [11..20] 4 even a == odd b]

20 beschreibungen beschreibungen sd der mathematischen Mengen-Notation nachempfunden. Beispiel: 1 sm = [x x <- " abraham ", x < i ] 2 pairs = [(a,b +1) a <- " aber ", b <- [1,2,3]] beschreibungen, 3 evenodd = [(a,b,a+b) a <- [1..10], b <- [11..20] 4 even a == odd b] Allgemee Form: 1 [ f x y... x <- X, cond x, 2 y <- Y, cond x y,...] X, Y,...:, aus denen Elemente kommen cond: Bedgungen, die diese erfuellen muessen f x y...: Elemente der neuen, die aus den ausgewaehlten x, y,... berechnet werden

21 beschreibung allgeme List Comprehension 1 [ expr qual1,..., qualn ] (wobei n >= 1) beschreibungen

22 beschreibung allgeme List Comprehension 1 [ expr qual1,..., qualn ] (wobei n >= 1) Qualifier ist: Generator: pat <- expr beschreibungen

23 beschreibung allgeme List Comprehension 1 [ expr qual1,..., qualn ] (wobei n >= 1) Qualifier ist: Generator: pat <- expr Guard (oder Filter): boolexpr beschreibungen

24 beschreibung allgeme List Comprehension 1 [ expr qual1,..., qualn ] (wobei n >= 1) Qualifier ist: Generator: pat <- expr Guard (oder Filter): boolexpr lokale Deklaration: let decls beschreibungen

25 beschreibung allgeme List Comprehension 1 [ expr qual1,..., qualn ] (wobei n >= 1) Qualifier ist: Generator: pat <- expr Guard (oder Filter): boolexpr lokale Deklaration: let decls beschreibungen Example 1 [ x * x x <- [1..20], odd x ]

26 beschreibung allgeme List Comprehension 1 [ expr qual1,..., qualn ] (wobei n >= 1) Qualifier ist: Generator: pat <- expr Guard (oder Filter): boolexpr lokale Deklaration: let decls beschreibungen Example 1 [ x * x x <- [1..20], odd x ] [1,9,25,49,81,121,169,225,289,361]

27 Auflösung von List Comprehensions Übersetzungsschema: [ expr True ] = [ expr ] beschreibungen

28 Auflösung von List Comprehensions Übersetzungsschema: [ expr True ] = [ expr ] [ expr qual, True ] = [ expr qual ] beschreibungen

29 Auflösung von List Comprehensions Übersetzungsschema: [ expr True ] = [ expr ] [ expr qual, True ] = [ expr qual ] [ expr guard, qual1,..., qualn ] = if guard then [ e qual1,..., qualn ] else [] beschreibungen

30 Auflösung von List Comprehensions Übersetzungsschema: [ expr True ] = [ expr ] [ expr qual, True ] = [ expr qual ] [ expr guard, qual1,..., qualn ] = if guard then [ e qual1,..., qualn ] else [] [ expr pat <- list, qual1,..., qualn] = let f pat = [ expr qual1,..., qualn ] f _ = [] concatmap f list beschreibungen

31 Auflösung von List Comprehensions Übersetzungsschema: [ expr True ] = [ expr ] [ expr qual, True ] = [ expr qual ] [ expr guard, qual1,..., qualn ] = if guard then [ e qual1,..., qualn ] else [] [ expr pat <- list, qual1,..., qualn] = let f pat = [ expr qual1,..., qualn ] f _ = [] concatmap f list [ expr let decls, qual1,..., qualn ] = let decls [ expr qual1,..., qualn ] beschreibungen

32 Elementare Funktionen auf Manche kennen wir bereits: head, tail length sum, product enumfromto append reverse take, drop map filter concat, concatmap!! nub beschreibungen

33 Mehr über Es folgen viele Beispiele von Funktionen über. Siehe Datei listtro.lhs beschreibungen