Grundlagen der Programmierung 2 (1.D)

Transkript

1 Grundlagen der Programmierung 2 (1.D) Prof. Dr. Manfred Schmidt-Schauÿ Künstliche Intelligenz und Softwaretechnologie 9. Mai 2006

2 Fallunterscheidung mit case Syntax: case Ausdruck of { Muster -> Ausdruck ;... ; Muster -> Ausdruck } Einschränkung: nur einfache Muster: K x 1... x n Kontextbedingung: die Muster müssen vom Typ her passen. Beispiel: und4 x y = case x of True -> y; False -> False Grundlagen der Programmierung 2 (1.D) - 1 -

3 case: Gültigkeitsbereich, FV und GV F V (case s of (c 1 x x 1n1 t 1 );... ; (c k x k1... x knk t k )) = F V (s) F V (t 1 ) \ {x 11,... x 1n1 }... F V (t k ) \ {x k1,... x knk } GV(.) entsprechend Grundlagen der Programmierung 2 (1.D) - 2 -

4 case: Gültigkeitsbereich, Beispiel F V (case x of True -> y; False -> False) = {x,y} F V (case x of (Punkt u v) -> u) = {x} GV (case x of (Punkt u v) -> u) = {u,v} Grundlagen der Programmierung 2 (1.D) - 3 -

5 Reduktionsregel zum case case-reduktion (case (c t 1... t n ) of... (c x 1... x n s)...) s[t 1 /x 1,..., t n /x n ] (mit sharing) (case (c t 1... t n ) of... (c x 1... x n s)...) let {x 1 = t 1 ;... ; x n = t n } in s Grundlagen der Programmierung 2 (1.D) - 4 -

6 Funktionsdefinitionen: Strategie Fallunterscheidungen mit Mustern in Funktionsdefinitionen: können als case-ausdrücke geschrieben werden. Haskell erlaubt überlappende Muster Auswertungs-Strategie in Funktionsdefinitionen mit Mustern und Wächtern: Muster von oben nach unten, bis Muster passt und Wächter = True Es gilt: Diese Strategie ist mittels geschachtelter case-ausdrücke definierbar Grundlagen der Programmierung 2 (1.D) - 5 -

7 Auswertung in Haskell Kombination von Transformation und Auswertung: Haskell- Programm Entzuckerung Programm in Kernsprache Syntaxbaum des Programms transformierter Syntaxbaum Syntaxanalyse Auswertung (operationelle Semantik) Grundlagen der Programmierung 2 (1.D) - 6 -

8 Entzuckerung: Beispiel map f [] = [] map f (x:xs) = f x : map f xs kann man transformieren zu: map f lst = (case lst of [] -> []; (x:xs) -> f x : map f xs) (Nach einer Programmanalyse) Grundlagen der Programmierung 2 (1.D) - 7 -

9 Bemerkungen zu Normaler Reihenfolge der Auswertung Normale Reihenfolge der Auswertung ist erweitert um neue Reduktion: case-reduktion Normale Reihenfolge der Auswertung reduziert nicht unter Konstruktoren (auch nicht in Abstraktionen) Dadurch kann man (potentiell) unendliche Listen verarbeiten Grundlagen der Programmierung 2 (1.D) - 8 -

10 Rekursive Datenobjekte: Listen, Bäume,... Listen: (Nochmal) Eine eigene Definition des Datentyps Liste: data Liste a = Leereliste ListenKons a (Liste a) a : Typ der Objekte in der Liste Rekursiver Datentyp! Grundlagen der Programmierung 2 (1.D) - 9 -

11 Listen in Haskell Listen sind in Haskell eingebaut mit syntaktischer Sonderbehandlung So würde die Definition aussehen data [a] = [] a : [a] (Im Prinzip korrekt) Grundlagen der Programmierung 2 (1.D)

12 Typen von Listen [1,2,3,4,5] :: [Integer] [[1],[2,3],[4],[5]] :: [[Integer]] [] :: [a] "abcde" :: [Char] Liste von Zeichen (String) ["ein","satz"] :: [[Char]] Liste von Strings [( a,1),( b,2)] :: [(Char,Integer)] Liste von Paaren ([ a, b ],[1]) :: ([Char],[Integer]) Paar von Listen Grundlagen der Programmierung 2 (1.D)

13 Listenausdrücke, (list comprehensions) Syntax: [ Ausdruck Generator Filter {, { Generator Filter }} ]. Analog zu Mengenausdrücken, aber Reihenfolge der Listenelemente im Resultat wird festgelegt. Beispiele: [x x <- xs] %% = xs [f x x <- xs] %% = map f xs [x x <- xs, p x] %% = filter p xs [(x,y) x <- xs, y <-ys] %% = xs "kreuzprodukt" ys %% fuer endliche Listen [y x <- xs, y <-x] %% = concat Grundlagen der Programmierung 2 (1.D)

14 Listen-Komprehensionen [Resultatausdruck Generatoren,Testfunktionen] Generator: v <- liste generiert Elemente der Liste Prädikat: Test auf True/False. Element wird akzeptiert/nicht akz. Wirkungsweise: die Generatoren liefern nach und nach die Elemente der Listen. Wenn alle Prädikate zutreffen, wird Resultatausdruck in die Resultatliste aufgenommen. neue lokale Variablen sind möglich deren Geltungsbereich ist rechts von der Einführung Grundlagen der Programmierung 2 (1.D)

15 Listen-Komprehensionen: Beispiel [(x,y) x <- [1..10], even x, y <- [2..6], x < y] Resultat: [(2,3),(2,4),(2,5),(2,6),(4,5),(4,6)] Begründung: Erzeugungsreihenfolge: x y ? N N Y Y Y Y N N N N Y Y N N... Grundlagen der Programmierung 2 (1.D)

16 Listen-Komprehensionen: Beispiel [(x,y) x <- [1..10], y <- [1..x]] [(1,1), (2,1),(2,2), (3,1),(3,2),(3,3), (4,1),(4,2),(4,3),(4,4), (5,1),(5,2),(5,3),(5,4),(5,5), (6,1),(6,2),(6,3),(6,4),(6,5),(6,6), (7,1),(7,2),(7,3),(7,4),(7,5),(7,6),(7,7), (8,1),(8,2),(8,3),(8,4),(8,5),(8,6),(8,7),(8,8), (9,1),(9,2),(9,3),(9,4),(9,5),(9,6),(9,7),(9,8),(9,9), (10,1),(10,2),(10,3),(10,4),(10,5),(10,6),(10,7),(10,8),(10,9),(10,10)] Grundlagen der Programmierung 2 (1.D)

17 Listen-Komprehensionen: Beispiel Liste der nicht durch 2,3,5 teilbaren Zahlen. Die erste Nicht-Primzahl darin ist 49: > [x x <- [2..], x rem 2 /= 0, x rem 3 /= 0, x rem 5 /= 0] [7,11,13,17,19,23,29,31,37,41,43,47,49,53,59,61,67,71,73,77,79,83,89,91,.. Grundlagen der Programmierung 2 (1.D)

18 Listen-Komprehensionen: Beispiel Primzahlen primes = 2: [x x <- [3,5..], and (map (\t-> x mod t /= 0) (takewhile (\y -> y^2 < x) primes))] Grundlagen der Programmierung 2 (1.D)

19 Optimierungen: am Beispiel foldl foldl foldl f z [] foldl f z (x:xs) :: (a -> b -> a) -> a -> [b] -> a = z = foldl f (f z x) xs foldl :: (a -> b -> a) -> a -> [b] -> a foldl f a [] = a foldl f a (x:xs) = ((foldl f) $! (f a x)) xs fun $! x entspricht: Zuerst x auswerten, dann fun x Grundlagen der Programmierung 2 (1.D)

20 Ressourcenbedarf von foldl, foldr, foldl foldl und foldr haben unterschiedlichen Ressourcenbedarf in Abhängigkeit vom Operator foldl ist speicher-optimiertes foldl (abh. von Operator) foldr (++) [] xs ist schneller als foldl (++) [] xs foldl (+) 0 xs braucht weniger Platz als foldr (+) 0 xs Main> length (foldr (++) [] [[x] x <- [ ]]) 1000 :: Int (29036 reductions, cells) Main> length (foldl (++) [] [[x] x <- [ ]]) 1000 :: Int ( reductions, cells, 6 garbage collections) Grundlagen der Programmierung 2 (1.D)

21 Weitere Listen-Funktionen Umdrehen einer Liste: reverse_naiv [] = [] reverse_naiv (x:xs) = (reverse_naiv xs) ++ [x] effizientes Umdrehen einer Liste: reverse xs = foldl (\x y -> y:x) [] xs Grundlagen der Programmierung 2 (1.D)

22 Weitere Listen-Funktionen -- Restliste nach n-tem Element drop 0 xs = xs drop _ [] = [] drop n (_:xs) n>0 = drop (n-1) xs drop = error "Prelude.drop: negative argument" -- Bildet Liste der Paare zip :: [a] -> [b] -> [(a,b)] zip (a:as) (b:bs) = (a,b) : zip as bs zip = [] --- aus Liste von Paaren ein Paar von Listen unzip :: [(a,b)] -> ([a],[b]) unzip = foldr (\(a,b) (as,bs) -> (a:as, b:bs)) ([], []) Grundlagen der Programmierung 2 (1.D)

23 Beispiele drop 10 [1..100] -----> [11,12,... zip "abcde" [1..] -----> [( a,1),( b,2),( c,3),( d,4),( e,5)] unzip (zip "abcdefg" [1..]) ----> ("abcdefg",[1,2,3,4,5,6,7]) Grundlagen der Programmierung 2 (1.D)

24 Ressourcenbedarf von Listenfunktionen Drei Möglichkeiten der Auswertung: Komplett-Auswertung z.b. beim Drucken der Ergebnisliste im Interpreter Rückgrat-Auswertung nur soviel, wie length von der Ergebnisliste benötigt. Kopf-Auswertung nur soviel, dass die Frage Ist die Ergebnisliste leer oder nicht leer beantwortet werden kann. Grundlagen der Programmierung 2 (1.D)

25 Ressourcenbedarf von Listenfunktionen. Beispiele lengthr [] = 0 lengthr (x:xs) = 1+lengthr xs length_lin xs = length_linr 0 xs length_linr s [] = s length_linr s (x:xs) = (length_linr $! (s+1)) xs Wenn lst bereits ausgewertet ist, und Länge n hat: lengthr lst length_lin lst benötigt O(n) Reduktionsschritte und O(n) Platz. benötigt O(n) Reduktionsschritte und O(1) Platz. Grundlagen der Programmierung 2 (1.D)

26 Ressourcenbedarf von Append xs,ys seien ausgewertete Listen der Länge m und n. Bei Rückgrat-Auswertung: xs ++ ys benötigt O(m + n) Reduktionsschritte O(m) Platz: nur das Rückgrat muss kopiert werden Grundlagen der Programmierung 2 (1.D)

27 Ressourcenbedarf von map xs sei ausgewertete Liste der Länge n map f xs: Rückgratauswertung: Komplett-Auswertung: Rückgratauswertung: Komplett-Auswertung: O(n) Reduktionsschritte # Reduktionsschritte abhängig von f O(n) Speicherbedarf Speicherbedarf abhängig von f Grundlagen der Programmierung 2 (1.D)

28 Ressourcenbedarf von concat Sei xs ausgewertete Liste von Listen der Länge m, das i-te Element sei eine Liste mit n i Elementen. concat xs bei Rückgratauswertung Reduktionsschritte: n 1 + n n m + m Platzbedarf: O(n n m 1 + m) letzte Liste muss nicht kopiert werden Grundlagen der Programmierung 2 (1.D)

29 Ein-Ausgabe in Haskell. Kurzeinführung: Ein-Ausgabe mittels IO-Aktionen Typ: a1 -> a2... -> IO a, Spezialfall: IO a Ein/Ausgabe durch Auswerten eines Ausdrucks vom Typ IO a a: Typ der Eingabe. Falls keine Eingabe, dann IO () Grundlagen der Programmierung 2 (1.D)

30 Vordefinierte Basis-IO-Aktionen putstr:: String -> IO () putstrln:: String -> IO () getline:: IO String print:: (Show a) => a -> IO () readln: (Read a) => IO a type FilePath = String writefile :: FilePath -> String -> IO () appendfile :: FilePath -> String -> IO () readfile :: FilePath -> IO String putstr, putstrln und print geben ihr Argument aus print und readln sind polymorph. Verwendete Methode ist abhängig vom statisch ermittelten Typ Grundlagen der Programmierung 2 (1.D)

31 Beispiele Das Hello-World-Programm: *Main> putstr "Hello World" Hello World*Main> Grundlagen der Programmierung 2 (1.D)

32 DO-Notation do-notation analog zu Listen-Komprehensionen bewirkt Kombination von Aktionen Ermöglicht Definition von neuen IO-Aktionen mittels vordefinierter IO-Aktionen Kontrollierte Selektion der Eingabe aus IO-Objekten do... arg <-... wirkt wie ein Selektor, Beispiel do {input <- getline; putstr input} äquivalent dazu ist: do input <- getline putstr input Grundlagen der Programmierung 2 (1.D)

33 Beispiel im Interpreter *Main> do {input <- getline; putstrln input} Hello -- eingetippt Hello -- Ausgabe *Main> Prelude> do {inp <- readln; putstr ((show (inp*2)) ++ "\n")} 3 6 Prelude> Grundlagen der Programmierung 2 (1.D)

34 Programmierbeschränkungen zu IO Kombination von Typisierung eingeschränktem Satz von vordefinierten IO-Aktionen nur do-notation darf selektieren bewirkt Programmierbeschränkungen die zum puren Programmieren passen: Trennung von Ein/Ausgabe und Auswertung Sequentialisierung der Ein-Ausgaben Grundlagen der Programmierung 2 (1.D)

35 Beispiele echoline:: IO String echoline = do input <- getline putstr input Einlesen einer Int-Zahl getnumber:: IO Int getnumber = do putstr "Bitte eine Zahl eingeben:" readln Grundlagen der Programmierung 2 (1.D)

36 Beispiele Parametrisierte Listen-Ausgabe: main = do a <- getnumber b <- getnumber print (take a (repeat b)) *Main> main Bitte eine Zahl eingeben:4 Bitte eine Zahl eingeben:6 [6,6,6,6] Grundlagen der Programmierung 2 (1.D)

37 Beispiele File lesen und ausgeben: filelesen = do putstr "File-Name:?" fname <-getline contents<-readfile fname putstr contents Grundlagen der Programmierung 2 (1.D)

38 Beispiele Wiederholte Nachfrage, ob (E)rgebnis gewünscht oder (W)eiter? weiter = do putstrln "(E)rgebnis oder (W)eiter?" w <- getline case (head w) of E -> return False W -> return True other -> weiter Rekursive Definition einer Aktion. Grundlagen der Programmierung 2 (1.D)

39 Beispiele Addieren beliebig vieler Zahlen addiere = addiere_ 0 addiere_ x = do a <- getnumber w <- weiter if w then addiere_ (a+x) else putstrln ("Das Ergebnis ist " ++ (show (a + x))) Grundlagen der Programmierung 2 (1.D)

40 Beispiele Addieren beliebig vieler Zahlen mit Speicherung der Eingabe addieres = addieres_ [] addieres_ xs = do a <- getnumber w <- weiter if w then addieres_ (a:xs) else putstrln $ (concat $ intersperse (" + ") ((reverse.map show) (a:xs))) ++ " = " ++ (show (sum (a:xs))) Grundlagen der Programmierung 2 (1.D)

41 Modularisierung in Haskell Module dienen zur Strukturierung / Hierarchisierung Kapselung: Wiederverwendbarkeit: Grundlagen der Programmierung 2 (1.D)

42 Definition eines Moduls Zum Modul gehören: Funktionen, Datentypen, Typsynonyme können exportiert werden, von anderen Modulen importiert werden Syntax module Modulname(Exportliste) where Modulimporte, Datentypdefinitionen, Funktionsdefinitionen,... Modulrumpf Für jedes Modul muss eine separate Datei angelegt werden, wobei der Modulname dem Dateinamen ohne Dateiendung entsprechen muss. Grundlagen der Programmierung 2 (1.D)

43 Programme und Module Haskell-Programm besteht aus einer Menge von Modulen Das Modul Main muss existieren und eine Funktion namens main :: IO () definieren und exportieren. Grundgerüst eines Haskell-Programms: module Main(main) where... main = Grundlagen der Programmierung 2 (1.D)

44 Modulexport und -import Beispiel module Spiel where data Ergebnis = Sieg Niederlage Unentschieden berechneergebnis a b = if a > b then Sieg else if a < b then Niederlage else Unentschieden istsieg Sieg = True istsieg _ = False istniederlage Niederlage = True istniederlage _ = False Exportliste: Funktionen oder Typen mit oder ohne Konstruktoren auch importierte Namen können wieder exportierten werden Grundlagen der Programmierung 2 (1.D)

45 Modulimport Mittels import am Anfang des Modulrumpfs. Varianten: import Modulname importiert alle Einträge der Exportliste von Modulname import Modulname(N1,N2,...) importiert spezifizierte Namen von Modulname import Spiel hiding(...) importiert alles bis auf... Grundlagen der Programmierung 2 (1.D)

46 Aufruf von Funktionen: Namenskonventionen Aufruf von importierten Funktionen: mit unqualifizierten Namen mitmodulname.unqualifizierter Name Beispiel zur Notwendigkeit qualifizierter Namen: module A(f) where f a b = a + b module B(f) where f a b = a * b module C where import A import B g1 = f f 3 4 g2 = A.f B.f funktioniert nicht -- funktioniert Grundlagen der Programmierung 2 (1.D)

47 Übersicht zur Sichtbarkeit der Namen Modul M exportiert f und g, Import-Deklaration import M import M() import M(f) import qualified M import qualified M() import qualified M(f) import M hiding () import M hiding (f) import qualified M hiding () import qualified M hiding (f) import M as N import M as N(f) import qualified M as N definierte Namen f, g, M.f, M.g keine f, M.f M.f, M.g keine M.f f, g, M.f, M.g g, M.g M.f, M.g M.g f, g, N.f, N.g f, N.f N.f, N.g Grundlagen der Programmierung 2 (1.D)