La fabbrica dei tesori

Tipi fantasma

I tipi di Elm permettono tipi generici, che generalmente aggiungono flessibilità a un'interfaccia. Ad esempio, il tipo Maybe a può contenere un valore di qualsiasi tipo.

type Maybe a = Nothing | Just a

Nota che nell'esempio sopra, il parametro di tipo a è usato su entrambi i lati del segno di uguale =. Diciamo che a è legato ad alcuni dati all'interno della definizione del tipo.

La tecnica del tipo fantasma

In alcuni casi, tuttavia, il parametro di tipo appare solo sul lato sinistro dell'equazione.

type Distance unit = Distance Float

Nella definizione di Distance sopra, unit è un parametro di tipo libero, non legato ad alcun dato nel tipo. Possiamo anche chiamare questo tipo un tipo fantasma.

È sorprendentemente utile quando vogliamo imporre vincoli al momento della compilazione. Ad esempio, vogliamo assicurarci di sommare solo distanze della stessa 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)

Il codice al di fuori di quel modulo non può accedere all'interno del tipo Distance. Gli utenti possono sommare due Distance Meter ma non possono sommare un Distance Meter con 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

Record estensibili come tipi fantasma

Non c'è alcuna restrizione su quali tipi possano essere fantasma, e anche i tipi record possono essere usati. Quando vengono usati come tipi fantasma, i record sono in grado di esprimere vincoli complessi che possono trasformarsi attraverso le funzioni.

Aggiungiamo una nuova unità di distanza all'interno del modulo Distance chiamata LegoBlock. I blocchi fisici, essendo oggetti regolamentati, hanno sempre due proprietà: hanno distanze non frazionarie e non negative.

type LegoBlock = LegoBlock

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

nonFractional e nonNegative sono i campi di un record che non esiste al di fuori di un argomento di tipo, quindi è appropriato dare loro il tipo (), chiamato tipo unità, che non contiene alcuna informazione oltre al fatto di esserci.

Ottenere distanze LegoBlock arbitrarie è ovviamente possibile, ad esempio dopo aver calcolato differenze o rapporti di distanze.

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

Tutti i valori sopra sono validi e verranno compilati, tuttavia abbiamo un interesse particolare per valori come fourStuds che hanno entrambe le proprietà nonFractional e nonNegative perché rappresentano blocchi fisici che possono essere combinati con

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

Aggiungiamo alcune funzioni per permettere agli utenti di creare e raffinare distanze 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)

Nota che floorDistance, ceilingDistance e absDistance possono gestire unità diverse da LegoBlock, e in generale non fanno alcuna assunzione sulle proprietà di input, garantiscono semplicemente che l'output avrà una proprietà specifica, o nonFractional o nonNegative.

Vediamo alcuni risultati.

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))

In generale, floorDistance e ceilingDistance forniscono risultati diversi, ma le stesse garanzie. Questa è la forza della tecnica del tipo fantasma: offrire scelte flessibili agli utenti mantenendo garanzie forti.