Tipos fantasma
Los tipos de Elm permiten tipos genéricos, que por lo general agregan 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 que en el ejemplo de arriba, el parámetro de tipo a se usa en ambos lados del signo igual =.
Decimos que a está vinculado a algún dato 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 de arriba, unit es un parámetro de tipo libre, no está vinculado a ningún dato del tipo.
También podemos llamar a este tipo un tipo fantasma.
Es sorprendentemente útil cuando queremos imponer restricciones en tiempo de compilación.
Por ejemplo, queremos asegurarnos de que solo sumamos 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.
Agreguemos una nueva unidad de distancia dentro del módulo Distance, llamada LegoBlock.
Los bloques físicos, al ser objetos regulados, siempre tienen dos propiedades: tienen distancias no fraccionarias y no 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 adecuado darles el tipo (), llamado el tipo unit, que no contiene información más allá del hecho de que está ahí.
Obtener distancias LegoBlock arbitrarias es, por supuesto, posible, por ejemplo después de calcular diferencias o razones 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, tenemos un interés especial en valores como fourStuds que tienen tanto la propiedad nonFractional como la nonNegative, 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
Agreguemos 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 que floorDistance, ceilingDistance y absDistance pueden trabajar con unidades distintas de LegoBlock y, en general, no hacen ninguna suposición sobre las propiedades de sus argumentos; solo garantizan que la salida tendrá una propiedad específica, 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 ofrecen resultados distintos, pero las mismas garantías.
Esta es la fortaleza de la técnica del tipo fantasma: ofrecer opciones flexibles a los usuarios mientras se mantienen garantías sólidas.
Ejercicio de aprendizaje
