Progwerkstatt: Funktionale Programmierung

Funktionale Programmierung
Datentypen und Typklassen
Philipp Güttler | 14.7.2009 | Progwerkstatt
Seite 2
Haskell | 2009
Basistypen in Haskell
•
Bool
True und False
•
Char
Zeichen
•
String
Zeichenfolgen [Char ]
•
Int
Ganze Zahlen (32-bit)
•
Integer Ganze Zahlen beliebiger Länge
•
Float
•
Double Fließkommazahlen mit doppelter Genauigkeit
Fließkommazahlen
Seite 3
Haskell | 2009
Zusammengesetzte Typen
•
Listen
[Int] als Listen von Integers, mit Werten wie [1, 2, 3]
•
Tupel
(Bool, Int) als Tupel von (True; 2)
•
Verbunde
BI{b::Bool ; i::Int} für BI {b = True; i = 2}
•
Funktionen
a -> b, z.B. Int -> Bool
•
-> Typdeklaration i :: Int
•
-> Typsynonyme type IntList = [Int], type String = [Char]
Seite 4
Haskell | 2009
Eigene Typen
•
Aufzählungstypen
data Jahreszeit = Fruehling | Sommer | Herbst |
Winter
•
Typen mit Feldern
data Feiertag = Geburtstag String Int Int Int
| Heirat String String Int Int Int
hansGeburtstag :: Feiertag
hansGeburtstag = Geburtstag "Hans" 1994 12 2
toString :: Feiertag -> String
showGeburtstage (Geburtstag name jahr monat tag)...
Seite 5
Haskell | 2009
Parametrisierte Typen
•
Generische Datentypen durch Typvariablen
data Tree a = Leaf a | Branch (Tree a) (Tree a)
Seite 6
Haskell | 2009
Typsynonyme
data Feier = Geburtstag String Date
data Date = Date Tag Monat Jahr
type Tag = Int
type Monat = Int
type Jahr = Int
hansGeburtstag = Geburtstag "hans" (Date 12 3 1994)
Seite 7
Haskell | 2009
Typklassen
•
zu vergleichen mit Interfaces/Templates
•
Typklassen sind keine Typen!
•
nur für Datentypen
•
Mehrfachvererbung möglich
Seite 8
Haskell | 2009
Haskell Prelude-Klassen
Eq
==, /=
Ord
<, <=, >, >=, min, max
Num
Addition, Subtraktion..
Enum
für Aufzählungen, wie [1 .. 10]
Bounded für Aufzählungen, Beispiel: Int (minBound, maxBound)
Show
Umwandlung Wert nach String
Read
Umwandeln von Eingaben; String nach Wert
Seite 9
Haskell | 2009
Beispiel
class
Eq a
where
(==), (/=) :: a -> a -> Bool
x /= y
=
not (x == y)
x == y
=
not (x /= y)
data Foo = Foo {x :: Integer, str :: String}
instance Eq Foo where
(Foo x1 str1) == (Foo x2 str2) =
(x1 == x2) && (str1 == str2)
mehrere Typklassen
instance (Eq, Num) => Foo
Seite 10
Haskell | 2009
Deriving
•
magische Automapfunktion
data Foo = Foo {x :: Integer, str :: String}
deriving (Eq, Ord, Show)
Seite 11
Haskell | 2009
Typbeschränkungen
plus :: a -> a -> a
plus x y = x + y
•
Typ a muss Addition unterstützen
plus :: Num a => a -> a -> a
•
Erweitert
foo :: (Num a, Show a, Show b) => a -> a -> b -> String