如何增强Haskell类型同义词区分度：保留底层表示且禁止混用

嘿，这个问题太戳中痛点了——我完全懂你那种“明明参数顺序搞反了逻辑上错得离谱，但编译器居然睁一只眼闭一只眼通过了”的挫败感！标准的Haskell类型同义词（用type定义的）确实因为完全透明的特性，没法做到你想要的“共享底层表示但类型层面严格区分”，不过咱们有几个非常成熟的方案能解决这个问题：

方案1：用newtype创建新类型（最推荐） #

这是Haskell里解决这类问题的标准做法，newtype允许你给现有类型套一个新的“类型壳”，运行时完全没有额外开销（编译器会优化掉包装层），但类型层面会被视为完全不同的类型，从根源上阻止了混用。

比如原来的代码可能是这样的：

type Velocity = Double
type Position = Double

-- 这里把Velocity和Position传反了也不会报错
updatePos :: Position -> Velocity -> Position
updatePos pos vel = pos + vel

改成newtype之后：

-- 给Double分别套上Velocity和Position的类型壳
newtype Velocity = Velocity Double
newtype Position = Position Double

-- 现在这个函数如果参数传反，编译器直接报错！
updatePos :: Position -> Velocity -> Position
updatePos (Position pos) (Velocity vel) = Position (pos + vel)

为了方便访问底层值，你可以定义辅助函数或者用记录语法：

-- 记录语法自动生成unwrapper函数
newtype Velocity = Velocity { unVelocity :: Double }
newtype Position = Position { unPosition :: Double }

-- 用unwrapper直接取出底层值计算
updatePos :: Position -> Velocity -> Position
updatePos pos vel = Position $ unPosition pos + unVelocity vel

如果不想手动给新类型推导Num、Show等实例，还可以用GHC的扩展简化：

{-# LANGUAGE GeneralizedNewtypeDeriving #-}

newtype Velocity = Velocity Double deriving (Num, Show, Eq)
newtype Position = Position Double deriving (Num, Show, Eq)

-- 现在可以直接对Velocity做数值运算，不用手动拆包
addVelocities :: Velocity -> Velocity -> Velocity
addVelocities v1 v2 = v1 + v2

方案2：用幻影类型（Phantom Types）做灵活标记 #

如果你需要更灵活的类型标记，不想每次都显式拆包/打包，可以用幻影类型——也就是带一个“幽灵”类型参数的类型，这个参数只在类型层面起作用，不影响运行时表示。

示例代码：

-- 定义两个空的标记类型，只用来区分
data VelocityTag
data PositionTag

-- 底层是Double，a是幻影类型参数
type Quantity a = Double

-- 用智能构造函数确保创建正确的类型
velocity :: Double -> Quantity VelocityTag
velocity = id

position :: Double -> Quantity PositionTag
position = id

-- 函数参数限定标记类型，传反直接报错
updatePos :: Quantity PositionTag -> Quantity VelocityTag -> Quantity PositionTag
updatePos pos vel = pos + vel  -- 底层都是Double，直接运算即可

不过这个方案有个小缺点：如果有人直接通过类型注解绕开智能构造函数（比如5 :: Quantity VelocityTag），还是能创建出不符合预期的类型，所以需要团队约定只用智能构造函数来创建Quantity实例。

为什么标准类型同义词做不到？ #

最后再解释下根源：Haskell的type定义是类型同义词，本质上是给现有类型起了个别名，编译器会在类型检查阶段直接把同义词替换成底层类型，所以Velocity和Position在编译器眼里完全就是Double，自然没法区分。而上面的两个方案都是通过创建全新的类型（或带参数的类型），让编译器能识别出它们的差异。

内容的提问来源于stack exchange，提问作者Austin Garrett