Haskell Language
Création de types de données personnalisés

Créer un type de données simple

La méthode la plus simple pour créer un type de données personnalisé dans Haskell consiste à utiliser le mot-clé data :

data Foo = Bar | Biz

Le nom du type est spécifié entre data et = et est appelé constructeur de type . Après = nous spécifions tous les constructeurs de valeurs de notre type de données, délimité par le | signe. Il existe une règle dans Haskell selon laquelle tous les constructeurs de types et de valeurs doivent commencer par une majuscule. La déclaration ci-dessus peut se lire comme suit:

Définissez un type appelé Foo , qui a deux valeurs possibles: Bar et Biz .

Création de variables de notre type personnalisé

let x = Bar

L'instruction ci-dessus crée une variable nommée x de type Foo . Vérifions cela en vérifiant son type.

:t x

estampes

x :: Foo

Création d'un type de données avec des paramètres de constructeur de valeur

Les constructeurs de valeurs sont des fonctions qui renvoient une valeur d'un type de données. De ce fait, comme toute autre fonction, ils peuvent prendre un ou plusieurs paramètres:

data Foo = Bar String Int | Biz String

Vérifions le type du constructeur de la valeur Bar .

:t Bar

estampes

Bar :: String -> Int -> Foo

ce qui prouve que Bar est bien une fonction.

Création de variables de notre type personnalisé

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

Création d'un type de données avec des paramètres de type

Les constructeurs de types peuvent prendre un ou plusieurs paramètres de type:

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

Les paramètres de type dans Haskell doivent commencer par une lettre minuscule. Notre type de données personnalisé n'est pas encore un type réel. Afin de créer des valeurs de notre type, nous devons substituer tous les paramètres de type aux types réels. Comme a et b peuvent être de tout type, nos constructeurs de valeurs sont des fonctions polymorphes.

Création de variables de notre type personnalisé

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

Type de données personnalisé avec paramètres d'enregistrement

Supposons que nous voulions créer un type de données Personne qui a un prénom et un nom, un âge, un numéro de téléphone, une rue, un code postal et une ville.

Nous pourrions écrire

data Person = Person String String Int Int String String String

Si nous voulons maintenant obtenir le numéro de téléphone, nous devons créer une fonction

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

Eh bien, ce n'est pas amusant. Nous pouvons faire mieux en utilisant les paramètres:

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

Maintenant, nous obtenons le phone fonction où

:t phone
phone :: Person' -> Int

Nous pouvons maintenant faire ce que nous voulons, par exemple:

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

Nous pouvons également lier le numéro de téléphone par correspondance de motif :

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

Pour une utilisation facile des paramètres, voir RecordWildCards