Haskell Language
Skapa anpassade datatyper

Skapa en enkel datatyp

Det enklaste sättet att skapa en typ anpassad data i Haskell är att använda data nyckelordet:

data Foo = Bar | Biz

Namnet på typen anges mellan data och = och kallas typkonstruktör . Efter = anger vi alla värdekonstruktörer av vår datatyp, avgränsade av | tecken. Det finns en regel i Haskell att alla konstruktörer av typ och värde måste börja med en stor bokstav. Ovanstående förklaring kan läsas enligt följande:

Definiera en typ som heter Foo , som har två möjliga värden: Bar och Biz .

Skapa variabler av vår anpassade typ

let x = Bar

Ovanstående uttalande skapar en variabel som heter x av typen Foo . Låt oss verifiera detta genom att kontrollera dess typ.

:t x

grafik

x :: Foo

Skapa en datatyp med värdekonstruktörsparametrar

Värdekonstruktörer är funktioner som returnerar ett värde av en datatyp. På grund av detta, precis som alla andra funktioner, kan de ta en eller flera parametrar:

data Foo = Bar String Int | Biz String

Låt oss kontrollera typen av Bar värde-konstruktör.

:t Bar

grafik

Bar :: String -> Int -> Foo

vilket bevisar att Bar verkligen är en funktion.

Skapa variabler av vår anpassade typ

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

Skapa en datatyp med typparametrar

Typkonstruktörer kan ta en eller flera typparametrar:

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

Skrivparametrar i Haskell måste börja med en liten bokstav. Vår anpassade datatyp är ännu inte en riktig typ. För att skapa värden av vår typ måste vi ersätta alla typparametrar med faktiska typer. Eftersom a och b kan vara av alla slag är våra värdekonstruktörer polymorfa funktioner.

Skapa variabler av vår anpassade typ

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

Anpassad datatyp med postparametrar

Antag att vi vill skapa en datatyp Person, som har ett för- och efternamn, en ålder, ett telefonnummer, en gata, ett postnummer och en stad.

Vi kunde skriva

data Person = Person String String Int Int String String String

Om vi nu vill få telefonnummer måste vi göra en funktion

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

Det här är inte kul. Vi kan göra bättre med hjälp av parametrar:

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

Nu får vi funktionen phone där

:t phone
phone :: Person' -> Int

Vi kan nu göra vad vi vill, till exempel:

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

Vi kan också binda telefonnumret genom Pattern Matching :

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

Se RecordWildCards för enkel användning av parametrarna