This lets the compiler recognize phantom types and ensure they aren't used improperly.
The use of a type system to guarantee well-formedness.
We create a Parameterized type in which the parameter does not appear on the rhs (shameless cutting and pasting from Daan Leijen and Erik Meijer)
data Expr a = Expr PrimExpr constant :: Show a => a -> Expr a (.+.) :: Expr Int -> Expr Int -> Expr Int (.==.) :: Eq a=> Expr a-> Expr a-> Expr Bool (.AND.):: Expr Bool -> Expr Bool-> Expr Bool data PrimExpr = BinExpr BinOp PrimExpr PrimExpr | UnExpr UnOp PrimExpr | ConstExpr String data BinOp = OpEq | OpAnd | OpPlus | ...
i.e. the datatype is such that we could get garbage such as
BinExpr OpEq (ConstExpr "1") (ConstExpr "\"foo\"")
but since we only expose the functions our attempts to create this expression via
constant 1 .==. constant "foo"
would fail to typecheck
I believe this technique is used when trying to interface with a language that would cause a runtime exception if the types were wrong but would have a go at running the expression first. (They use it in the context of SQL but I have also seen it in the context of FLI work.)
A foundation for embedded languages provides some formal background for embedding typed languages in Haskell, and also its references give a fairly comprehensive survey of uses of phantom types and related techniques.