La fabrique de trésors

Les types fantômes

Les types en Elm permettent d'utiliser des types génériques, ce qui apporte généralement de la souplesse à une interface. Par exemple, le type Maybe a peut contenir une valeur de n'importe quel type.

type Maybe a = Nothing | Just a

Note que dans l'exemple ci-dessus, le paramètre de type a est utilisé des deux côtés du signe égal =. On dit alors que a est lié à des données au sein de la définition du type.

La technique du type fantôme

Dans certains cas, cependant, le paramètre de type n'apparaît que du côté gauche de l'équation.

type Distance unit = Distance Float

Dans la définition de Distance ci-dessus, unit est un paramètre de type libre, lié à aucune donnée du type. On peut aussi appeler ce type un type fantôme.

C'est étonnamment utile lorsqu'on veut imposer des contraintes au moment de la compilation. Par exemple, on veut s'assurer qu'on n'additionne que des distances de même unité.

-- Distance is an opaque type, since the module does not expose its variants.
-- This means that users may only use the functions meter, foot and add to manipulate distances.
module Distance exposing (Distance, Meter, Foot, meter, foot, add)

-- The Distance type has a phantom type 'unit'.
type Distance unit = Distance Float

-- We define two types that will be used in place
-- of the phantom type 'unit' in our constructor functions.
type Meter = Meter
type Foot = Foot

-- Constructor for Meter
meter : Distance Meter
meter = Distance 1.0

-- Constructor for Foot
foot : Distance Foot
foot = Distance 0.3048

-- The add function cannot take two parameters of different types.
-- So we cannot add meters and feet by mistake.
add : Distance unit -> Distance unit -> Distance unit
add (Distance d1) (Distance d2) = Distance (d1 + d2)

Le code extérieur à ce module ne peut pas accéder à l'intérieur du type Distance. Les utilisateurs peuvent additionner deux Distance Meter, mais pas un Distance Meter avec un Distance Foot.

import Distance exposing (Distance)

-- Compiles
twoMeters = Distance.add Distance.meter Distance.meter

-- Does not compile
errDist = Distance.add Distance.meter Distance.foot

Les enregistrements extensibles comme types fantômes

Rien n'impose de restriction sur les types qui peuvent être fantômes, et les enregistrements peuvent l'être aussi. Lorsqu'ils servent de types fantômes, les enregistrements permettent d'exprimer des contraintes complexes qui peuvent se transformer au fil des fonctions.

Ajoutons une nouvelle unité de distance dans le module Distance, appelée LegoBlock. Les blocs physiques, en tant qu'objets réglementés, ont toujours deux propriétés : leur distance est non fractionnaire et non négative.

type LegoBlock = LegoBlock

fourStuds : Distance { properties | unit: LegoBlock, nonFractional : (), nonNegative: () }
fourStuds = Distance 4.0

nonFractional et nonNegative sont les champs d'un enregistrement qui n'existe pas en dehors d'un argument de type. Il est donc logique de leur donner le type (), appelé le type unité, qui ne porte aucune information sinon le fait d'être là.

Il est bien sûr possible d'obtenir des distances LegoBlock arbitraires, par exemple en calculant des différences ou des rapports de distances.

negativeStud : Distance { properties | unit: LegoBlock, nonFractional : () }
negativeStud = Distance -1.0

threeFiddyStud : Distance { properties | unit: LegoBlock, nonNegative : () }
threeFiddyStud = Distance 3.50

crazyStud : Distance { properties | unit: LegoBlock }
crazyStud = Distance -13.37

Toutes les valeurs ci-dessus sont valides et se compilent, cependant on s'intéresse particulièrement aux valeurs comme fourStuds qui possèdent à la fois les propriétés nonFractional et nonNegative, car elles représentent des blocs physiques que l'on peut combiner avec

combineLegoBlocks
  :  Distance { properties | unit: LegoBlock, nonFractional : (), nonNegative: () }
  -> Distance { properties | unit: LegoBlock, nonFractional : (), nonNegative: () }
  -> Distance { properties | unit: LegoBlock, nonFractional : (), nonNegative: () }
combineLegoBlocks = add

Ajoutons quelques fonctions pour permettre de créer et d'affiner des distances LegoBlock.

newLegoBlock : Float -> Distance { properties | unit: LegoBlock }
newLegoBlock dist = Distance dist

floorDistance : Distance properties -> Distance { properties | nonFractional : () }
floorDistance (Distance dist) = Distance (toFloat (floor dist))

ceilingDistance : Distance properties -> Distance { properties | nonFractional : () }
ceilingDistance (Distance dist) = Distance (toFloat (ceiling dist))

absDistance : Distance properties -> Distance { properties | nonNegative : () }
absDistance (Distance dist) = Distance (abs dist)

Note que floorDistance, ceilingDistance et absDistance peuvent gérer d'autres unités que LegoBlock et, d'une manière générale, ne font aucune supposition sur les propriétés en entrée : elles garantissent seulement que le résultat aura une propriété précise, nonFractional ou nonNegative.

Regardons quelques résultats.

import Distance exposing (Distance)

-- Compiles
distance1 = combineLegoBlocks fourStuds fourStuds

-- Does not compile
distance2 = combineLegoBlocks fourStuds threeFiddyStud

-- Compiles
distance3 = combineLegoBlocks fourStuds (floorDistance threeFiddyStud)

-- Does not compile
distance4 = combineLegoBlocks fourStuds negativeStud

-- Compiles
distance5 = combineLegoBlocks fourStuds (absDistance negativeStud)

-- Does not compile
distance6 = combineLegoBlocks fourStuds crazyStud

-- Compiles
distance7 = combineLegoBlocks fourStuds (floorDistance (absDistance crazyStud))

-- Compiles
distance8 = combineLegoBlocks fourStuds (ceilingDistance (absDistance crazyStud))

D'une manière générale, floorDistance et ceilingDistance donnent des résultats différents, mais offrent les mêmes garanties. C'est toute la force de la technique du type fantôme : offrir des choix souples aux utilisateurs tout en conservant de solides garanties.