Haskell Language
Syntaxe d'enregistrement

Syntaxe de base

Les enregistrements sont une extension du type de data algébrique somme qui permet de nommer les champs:

data StandardType = StandardType String Int Bool --standard way to create a sum type

data RecordType = RecordType { -- the same sum type with record syntax
    aString :: String
  , aNumber :: Int
  , isTrue  :: Bool
  }

Les noms de champs peuvent alors être utilisés pour extraire le champ nommé

> let r = RecordType {aString = "Foobar", aNumber= 42, isTrue = True}
> :t r
  r :: RecordType
> :t aString
  aString :: RecordType -> String
> aString r
  "Foobar"

Les enregistrements peuvent être associés à un motif

case r of
  RecordType{aNumber = x, aString=str} -> ... -- x = 42, str = "Foobar"

Notez que tous les champs ne doivent pas être nommés

Les enregistrements sont créés en nommant leurs champs, mais peuvent également être créés en tant que types de somme ordinaires (souvent utiles lorsque le nombre de champs est petit et peu susceptible de changer)

r  = RecordType {aString = "Foobar", aNumber= 42, isTrue = True}
r' = RecordType  "Foobar" 42 True

Si un enregistrement est créé sans champ nommé, le compilateur émettra un avertissement et la valeur résultante sera undefined .

> let r = RecordType {aString = "Foobar", aNumber= 42}
  <interactive>:1:9: Warning:
     Fields of RecordType not initialized: isTrue
> isTrue r
  Error 'undefined'

Un champ d'un enregistrement peut être mis à jour en définissant sa valeur. Les champs non mentionnés ne changent pas.

> let r = RecordType {aString = "Foobar", aNumber= 42, isTrue = True}
> let r' = r{aNumber=117}
    -- r'{aString = "Foobar", aNumber= 117, isTrue = True}

Il est souvent utile de créer des objectifs pour des types d’enregistrements complexes.

Copier des enregistrements en changeant les valeurs de champs

Supposons que vous ayez ce type:

data Person = Person { name :: String, age:: Int } deriving (Show, Eq)

et deux valeurs:

alex = Person { name = "Alex", age = 21 }
jenny = Person { name = "Jenny", age = 36 }

Une nouvelle valeur de type Person peut être créée en copiant depuis alex , en spécifiant les valeurs à modifier:

anotherAlex = alex { age = 31 }

Les valeurs de alex et anotherAlex seront maintenant:

Person {name = "Alex", age = 21}

Person {name = "Alex", age = 31}

Records avec newtype

La syntaxe d'enregistrement peut être utilisée avec newtype avec la restriction qu'il existe exactement un constructeur avec un seul champ. L'avantage ici est la création automatique d'une fonction pour dérouler le nouveau type. Ces champs sont souvent nommés en commençant par run pour les monads, get pour les monoids et un pour les autres types.

newtype State s a = State { runState :: s -> (s, a) }

newtype Product a = Product { getProduct :: a }

newtype Fancy = Fancy { unfancy :: String } 
  -- a fancy string that wants to avoid concatenation with ordinary strings

Il est important de noter que la syntaxe de l’enregistrement n’est généralement pas utilisée pour former des valeurs et que le nom du champ est strictement utilisé pour le dépliage.

getProduct $ mconcat [Product 7, Product 9, Product 12]
-- > 756

RecordWildCards

{-# LANGUAGE RecordWildCards #-}

data Client = Client { firstName     :: String
                     , lastName      :: String
                     , clientID      :: String 
                     } deriving (Show)

printClientName :: Client -> IO ()
printClientName Client{..} = do
    putStrLn firstName
    putStrLn lastName
    putStrLn clientID

Le modèle Client{..} apporte la portée à tous les champs du constructeur Client , et est équivalent au pattern

Client{ firstName = firstName, lastName = lastName, clientID = clientID }

Il peut également être combiné avec d'autres agents de terrain, comme ceci:

Client { firstName = "Joe", .. }

Ceci est équivalent à

Client{ firstName = "Joe", lastName = lastName, clientID = clientID }

Définition d'un type de données avec des étiquettes de champ

Il est possible de définir un type de données avec des étiquettes de champ.

data Person = Person { age :: Int, name :: String }

Cette définition diffère d'une définition d'enregistrement normale car elle définit également * les accesseurs d'enregistrement qui peuvent être utilisés pour accéder à des parties d'un type de données.

Dans cet exemple, deux accesseurs d’enregistrement sont définis: age et name , ce qui nous permet d’accéder respectivement aux champs age et name .

age :: Person -> Int
name :: Person -> String

Les accesseurs d'enregistrements ne sont que des fonctions Haskell générées automatiquement par le compilateur. En tant que tels, ils sont utilisés comme des fonctions Haskell ordinaires.

En nommant les champs, nous pouvons également utiliser les étiquettes de champs dans plusieurs autres contextes afin de rendre notre code plus lisible.

Correspondance de motif

lowerCaseName :: Person -> String
lowerCaseName (Person { name = x }) = map toLower x

Nous pouvons lier la valeur située à la position du libellé du champ concerné tout en faisant correspondre le modèle à une nouvelle valeur (dans ce cas x ) qui peut être utilisée sur le RHS d'une définition.

Correspondance de modèle avec NamedFieldPuns

lowerCaseName :: Person -> String
lowerCaseName (Person { name }) = map toLower name

L'extension NamedFieldPuns nous permet à la place de simplement spécifier le libellé du champ sur lequel nous voulons faire correspondre, ce nom est alors ombré sur le RHS d'une définition, ainsi la référence au name fait référence à la valeur plutôt qu'à l'accesseur d'enregistrement.

Correspondance de motifs avec RecordWildcards

lowerCaseName :: Person -> String
lowerCaseName (Person { .. }) = map toLower name

Lors de la correspondance à l'aide de RecordWildCards , toutes les étiquettes de champs sont intégrées à la portée. (Dans cet exemple spécifique, name et age )

Cette extension est légèrement controversée car on ne sait pas comment les valeurs sont intégrées si vous n'êtes pas certain de la définition de Person .

Mises à jour des enregistrements

setName :: String -> Person -> Person
setName newName person = person { name = newName }

Il existe également une syntaxe spéciale pour la mise à jour des types de données avec des étiquettes de champ.