Tipos fantasma
Los tipos de Elm permiten tipos genéricos, que en general aportan flexibilidad a una interfaz.
Por ejemplo, el tipo Maybe a puede contener un valor de cualquier tipo.
type Maybe a = Nothing | Just a
Fíjate en que, en el ejemplo anterior, el parámetro de tipo a se usa a ambos lados del signo igual =.
Decimos que a está ligado a algunos datos dentro de la definición del tipo.
La técnica del tipo fantasma
Sin embargo, en ciertos casos el parámetro de tipo solo aparece en el lado izquierdo de la ecuación.
type Distance unit = Distance Float
En la definición de Distance anterior, unit es un parámetro de tipo libre, no está ligado a ningún dato del tipo.
También podemos llamar a este tipo un tipo fantasma.
Resulta sorprendentemente útil cuando queremos imponer restricciones en tiempo de compilación.
Por ejemplo, queremos asegurarnos de sumar solo distancias de la misma unidad.
-- 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)
El código fuera de ese módulo no puede acceder al interior del tipo Distance.
Los usuarios pueden sumar dos Distance Meter, pero no pueden sumar 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
Registros extensibles como tipos fantasma
No hay ninguna restricción sobre qué tipos pueden ser fantasma, y los tipos de registro también se pueden usar.
Cuando se usan como tipos fantasma, los registros pueden expresar restricciones complejas que pueden transformarse a través de funciones.
Vamos a añadir una nueva unidad de distancia dentro del módulo Distance llamada LegoBlock.
Los bloques físicos, al ser objetos regulados, siempre tienen dos propiedades: sus distancias no son fraccionarias y no son negativas.
type LegoBlock = LegoBlock
fourStuds : Distance { properties | unit: LegoBlock, nonFractional : (), nonNegative: () }
fourStuds = Distance 4.0
nonFractional y nonNegative son los campos de un registro que no existe fuera de un argumento de tipo, así que es apropiado darles el tipo (), llamado el tipo unidad, que no contiene más información que el hecho de estar ahí.
Obtener distancias LegoBlock arbitrarias es, por supuesto, posible, por ejemplo tras calcular diferencias o cocientes de distancias.
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
Todos los valores anteriores son válidos y compilarán; sin embargo, nos interesan especialmente valores como fourStuds, que tienen las propiedades nonFractional y nonNegative a la vez, porque representan bloques físicos que se pueden combinar con
combineLegoBlocks
: Distance { properties | unit: LegoBlock, nonFractional : (), nonNegative: () }
-> Distance { properties | unit: LegoBlock, nonFractional : (), nonNegative: () }
-> Distance { properties | unit: LegoBlock, nonFractional : (), nonNegative: () }
combineLegoBlocks = add
Vamos a añadir algunas funciones para que los usuarios puedan crear y refinar distancias 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)
Fíjate en que floorDistance, ceilingDistance y absDistance pueden manejar unidades distintas de LegoBlock y, en general, no hacen ninguna suposición sobre las propiedades de entrada; simplemente garantizan que la salida tendrá una propiedad concreta, ya sea nonFractional o nonNegative.
Veamos algunos resultados.
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))
En general, floorDistance y ceilingDistance proporcionan resultados distintos, pero las mismas garantías.
Esta es la fuerza de la técnica del tipo fantasma: ofrecer opciones flexibles a los usuarios manteniendo garantías sólidas.
Ejercicio de aprendizaje
