Le coffre au trésor sécurisé

Types opaques

Introduction

Les types opaques sont une technique d'encapsulation en Elm. Certains parlent aussi de masquage d'information, ou de dissimulation des détails d'implémentation. On les utilise également couramment pour faire respecter une validation, avec le motif Parse, dont validate. Par exemple, on peut avoir un type opaque EmailAddress, qui ne peut contenir que des adresses e-mail valides (contrairement à une String, qui peut contenir n'importe quoi).

Crée un type opaque

Les types personnalisés ont une ou plusieurs variantes, et le compilateur génère automatiquement une fonction pour créer chaque variante, en utilisant le nom de la variante. C'est le seul moyen de créer des types personnalisés. Le compilateur permet aussi de déstructurer ces variantes.

type Maybe a
    = Nothing --> Variant implies a 'Nothing' function, with type 'Maybe a', and destructuring of 'Nothing'
    | Just a  --> Variant implies a 'Just' function, with type 'a -> Maybe a', and destructuring of 'Just _'

Par défaut, tout cela reste interne au fichier / module, et on utilise le mot-clé exposing pour choisir ce que l'on exporte. Pour créer un type opaque, il suffit de choisir de ne pas exporter les variantes.

Quand tu fais cela, tu dois presque toujours fournir un autre moyen de créer et de récupérer les variantes, en exposant des fonctions personnalisées. Ces fonctions personnalisées te permettent d'appliquer une certaine logique lors de la création et de la récupération des variantes. Cela masque les détails d'implémentation internes du module, et signifie que tu peux modifier les détails d'implémentation autant que tu le souhaites, tant que les fonctions exposées restent identiques.

Parse, don't validate

L'utilisation la plus courante des types opaques est probablement de faire respecter une validation, avec le motif Parse, dont validate. Dans ce motif, on expose une fonction qui prend une entrée moins structurée / moins sûre du point de vue des types que ce que l'on souhaite, comme une String, puis on l'analyse pour obtenir un type plus structuré, comme EmailAddress, en renvoyant soit le type, soit une erreur (généralement Maybe ou Result).

Par exemple, dans le code ci-dessous, les modules externes ne peuvent créer un type EmailAddress qu'avec la fonction parseEmailAddress, donc quand tu manipules le type EmailAddress, tu es certain qu'il est valide.

module EmailAddress exposing ( EmailAddress, parseEmailAddress, getEmailAddress )

-- The `EmailAddress` custom type has one variant, also called `EmailAddress`
-- When a custom type has one variant, it is idiomatic to use the same name for both.
type EmailAddress = 
  EmailAddress String

-- create an EmailAddress variant
parseEmailAddress: String -> Maybe EmailAddress
parseEmailAddress candidateEmailAddress =   
  if isValidEmailAddress candidateEmailAddress then
    Just (EmailAddress candidateEmailAddress)
  else
    Nothing

-- get an EmailAddress variant
getEmailAddress: EmailAddress -> String
getEmailAddress ( EmailAddress  emailAdress ) =
  emailAdress

isValidEmailAddress: String -> bool
-- ...