Haskell Language
Aangepaste gegevenstypen maken

Een eenvoudig gegevenstype maken

De eenvoudigste manier om een aangepast gegevenstype in Haskell te maken, is door het data trefwoord te gebruiken:

data Foo = Bar | Biz

De naam van het type wordt opgegeven tussen data en = en wordt een constructor van het type genoemd. Na = specificeren we alle waardeconstructors van ons gegevenstype, gescheiden door de | teken. Er is een regel in Haskell dat alle type- en waardeconstructors moeten beginnen met een hoofdletter. Bovenstaande verklaring kan als volgt worden gelezen:

Definieer een type genaamd Foo , dat twee mogelijke waarden heeft: Bar en Biz .

Variabelen maken van ons aangepaste type

let x = Bar

De bovenstaande instructie maakt een variabele met de naam x van het type Foo . Laten we dit verifiëren door het type te controleren.

:t x

prints

x :: Foo

Een gegevenstype maken met waardeconstructorparameters

Waardeconstructors zijn functies die een waarde van een gegevenstype retourneren. Hierdoor kunnen ze, net als elke andere functie, een of meer parameters aannemen:

data Foo = Bar String Int | Biz String

Laten we het type Bar constructor bekijken.

:t Bar

prints

Bar :: String -> Int -> Foo

wat bewijst dat Bar inderdaad een functie is.

Variabelen maken van ons aangepaste type

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

Een gegevenstype met typeparameters maken

Type-constructors kunnen een of meer typeparameters aannemen:

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

Typ parameters in Haskell moet beginnen met een kleine letter. Ons aangepaste gegevenstype is nog geen echt type. Om waarden van ons type te creëren, moeten we alle typeparameters vervangen door werkelijke typen. Omdat a en b van elk type kunnen zijn, zijn onze waardeconstructors polymorfe functies.

Variabelen maken van ons aangepaste type

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

Aangepast gegevenstype met recordparameters

Stel dat we een gegevenstype Persoon willen maken, met een voor- en achternaam, een leeftijd, een telefoonnummer, een straat, een postcode en een stad.

We kunnen schrijven

data Person = Person String String Int Int String String String

Als we nu het telefoonnummer willen krijgen, moeten we een functie maken

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

Nou, dit is niet leuk. We kunnen het beter doen met behulp van parameters:

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

Nu krijgen we de functie phone , waar

:t phone
phone :: Person' -> Int

We kunnen nu doen wat we willen, bijvoorbeeld:

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

We kunnen het telefoonnummer ook binden door Pattern Matching :

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

Zie RecordWildCards voor eenvoudig gebruik van de parameters