Andere Typen


... [ Seminar "Einführung in die funktionale Programmiersprache Haskell" ] ... [ Inhaltsverzeichnis ] ... [ zurück ] ... [ weiter ] ...

Übersicht: Andere Typen


Typen, die auf anderen Typen basieren


Ein Beispiel für einen Datentypen, der auf anderen Typen basiert ist folgende, polymorphe Definition:

01  data Either a b    =  Left a | Right b
02  Left   :: a -> Either a b
03  Right  :: b -> Either a b

Die Funktionen Left und Right sind Konstruktoren für den Datentyp und sie haben deshalb keine Definition. Die Namen Left und Right können auch als Muster auf der linken Seite von Definitionen auftauchen.

Die Anzahl der Werte im Datentyp ergibt sich wie beim Paar aus der Anzahl der Konstruktoren m für a und der Anzahl der Konstruktoren n für b. Auch hier muss bei beiden Typen der undefinierte Wert einbezogen werden und der undefinierte Wert undefined von Left undefined und Right undefined unterschieden werden.
Insgesamt ergeben sich also für den Datentyp 1 + (m + 1) + (n + 1) Werte.

Das folgende Beispiel kombiniert die Datentypen Bool und Char und besteht aus 261 Werten (3 Bool'sche Werte, 257 Char Werte und undefined).

01  data Either   =  Left Bool | Right Char


[ nach oben ]

Andere Typen als Argumente in Funktionen


Die folgenden Definitionen der Funktionen case und plus verwenden die Eigenschaft, dass die Konstruktoren auf der linken Seite von Definitionen auftauchen können. Das Wort plus kommt aus der Kategorientheorie und wird dort durch die Notation f + g bezeichnet.

01  case                  ::  (a -> c,b -> c) -> Either a b -> c
02  case (f,g) (Left x)    =  f x
03  case (f,g) (Right x)   =  g x
04  plus         ::  (a -> b,c -> d) -> Either a b -> Either c d
05  plus (f,g)    =  case(Left . f,Right . g)

Die Funktionen haben eine Reihe von Eigenschaften die im sogenannten "point-free"-Programmierstil ausgenutzt werden können. Diese Eigenschaften gelten allerdings nur für binäre Funktionen in der uncurried Schreibweise. Man kann hier eine Parallele zu den Eigenschaften der Funktionen pair und cross feststellen, die der zugrundeliegende Algebra entspringt.
Die vierte Eigenschaft kann mit Hilfe der anderen Eigenschaften bewiesen werden. Es wurde an dieser Stelle jedoch darauf verzichtet.

01  case (f,g) . Left         =  f
02  case (f,g) . Right        =  g
03  h . case (f,g)            =  case (h . f,h . g)
04  case (f,g) . plus (h,k)   =  case (f . h,g . k)


[ nach oben ]

Gleichheits- und Ordnungsrelation für andere Typen


Für andere Typen können leicht Instanzen der Typklassen Eq und Ord gebildet werden. Es gilt hier dieselbe Besonderheit wie bei der Definition bei Tupeln. Die einzelnen Typen, aus denen der Datentyp besteht, müssen ebenfalls Instanzen der jeweiligen Typklasse sein. Die Instanzen können auch automatisch mit Hilfe der deriving-Klausel erstellt werden.

01  instance (Eq a, Eq b) => Eq (Either a b) where
02    Left x  == Left y   =  (x == y)
03    Left x  == Right y  =  False
04    Right x == Left y   =  False
05    Right x == Right y  =  (x == y)
06  
07  instance (Ord a, Ord b) => Ord (Either a b) where
08    Left x   < Left y   =  (x < y)
09    Left x   < Right y  =  False
10    Right x  < Left y   =  False
11    Right x  < Right y  =  (x < y)


... [ Seminar "Einführung in die funktionale Programmiersprache Haskell" ] ... [ Inhaltsverzeichnis ] ... [ zurück ] ... [ weiter ] ... [ nach oben ] ...