Haskell Language
Benutzerdefinierte Datentypen erstellen

Einen einfachen Datentyp erstellen

Die einfachste Methode zum Erstellen eines benutzerdefinierten Datentyps in Haskell besteht im Verwenden des Schlüsselworts data :

data Foo = Bar | Biz

Der Name des Typs wird zwischen data und = und als Typkonstruktor bezeichnet . Nach = wir alle Wertkonstruktoren unseres Datentyps an, getrennt durch | Zeichen. In Haskell gibt es eine Regel, dass alle Typ- und Wertkonstruktoren mit einem Großbuchstaben beginnen müssen. Die obige Erklärung kann wie folgt gelesen werden:

Definieren Sie einen Typ namens Foo , der zwei mögliche Werte hat: Bar und Biz .

Erstellen von Variablen unseres benutzerdefinierten Typs

let x = Bar

Die obige Anweisung erstellt eine Variable mit dem Namen x vom Typ Foo . Lassen Sie uns dies überprüfen, indem Sie den Typ überprüfen.

:t x

druckt

x :: Foo

Datentyp mit Wertkonstruktorparametern erstellen

Wertkonstruktoren sind Funktionen, die einen Wert eines Datentyps zurückgeben. Aus diesem Grund können sie wie jede andere Funktion einen oder mehrere Parameter annehmen:

data Foo = Bar String Int | Biz String

Lassen Sie uns den Typ des Bar Wert-Konstruktors überprüfen.

:t Bar

druckt

Bar :: String -> Int -> Foo

was beweist, dass Bar tatsächlich eine Funktion ist.

Erstellen von Variablen unseres benutzerdefinierten Typs

let x = Bar "Hello" 10
let y = Biz "Goodbye"

Datentyp mit Typparametern erstellen

Typkonstruktoren können einen oder mehrere Typparameter annehmen:

data Foo a b = Bar a b | Biz a b

Die Parameter in Haskell müssen mit einem Kleinbuchstaben beginnen. Unser benutzerdefinierter Datentyp ist noch kein echter Typ. Um Werte unseres Typs zu erstellen, müssen wir alle Typparameter durch tatsächliche Typen ersetzen. Da a und b einen beliebigen Typ haben können, sind unsere Wertkonstruktoren polymorphe Funktionen.

Erstellen von Variablen unseres benutzerdefinierten Typs

let x = Bar "Hello" 10      -- x :: Foo [Char] Integer
let y = Biz "Goodbye" 6.0   -- y :: Fractional b => Foo [Char] b
let z = Biz True False      -- z :: Foo Bool Bool

Benutzerdefinierter Datentyp mit Datensatzparametern

Angenommen, wir möchten einen Datentyp Person erstellen, der Vor- und Nachname, Alter, Telefonnummer, Straße, Postleitzahl und Ort hat.

Wir könnten schreiben

data Person = Person String String Int Int String String String

Wenn wir jetzt die Telefonnummer erhalten möchten, müssen wir eine Funktion erstellen

getPhone :: Person -> Int
getPhone (Person _ _ _ phone _ _ _) = phone

Das macht keinen Spaß. Wir können Parameter besser nutzen:

data Person' = Person' { firstName     :: String
                       , lastName      :: String
                       , age           :: Int
                       , phone         :: Int
                       , street        :: String
                       , code          :: String
                       , town          :: String }

Jetzt bekommen wir die Funktion phone wo

:t phone
phone :: Person' -> Int

Wir können jetzt machen, was wir wollen, zB:

printPhone :: Person' -> IO ()
printPhone = putStrLn . show . phone

Wir können die Telefonnummer auch über Pattern Matching binden:

getPhone' :: Person' -> Int
getPhone' (Person {phone = p}) = p

Informationen zur einfachen Verwendung der Parameter finden Sie unter RecordWildCards