如何在Haskell子类实例中优化超类方法实现？

答案是可以的，但Haskell的类型类模型和OOP的“继承-重写”机制有本质区别，不能直接在子类实例里覆盖超类方法。不过我们可以通过几种方式实现类似的效果，下面结合你的具体场景来讲解。

为什么直接重写不行？ #

在Haskell中，超类（比如Model）的方法属于超类的实例定义，子类（比如CoherentModel）只是约束——它要求类型必须先满足超类，但子类实例本身不能定义超类的方法。这和OOP里子类继承并覆盖父类方法的逻辑不同，Haskell的类型类是基于“实例匹配”的，每个类型的超类方法实现由对应的超类实例决定，子类实例无法修改这一点。

解决方案1：利用默认签名 + 条件约束 #

我们可以在超类Model中，给con方法添加一个默认实现，当类型同时是CoherentModel时，自动使用高效的成对检查版本。需要开启DefaultSignatures和ConstraintKinds扩展：

{-# LANGUAGE DefaultSignatures, ConstraintKinds #-}

class Model a where
  con :: [a] -> Bool
  -- 默认实现：如果a是CoherentModel，用高效版本；否则需要用户提供
  default con :: CoherentModel a => [a] -> Bool
  con = (all . uncurry) (=^=) . pairs
    where
      pairs [] = []
      pairs [_] = []
      pairs (x:xs) = map ((,) x) xs ++ pairs xs

class Model a => CoherentModel a where
  (=^=) :: a -> a -> Bool
  a =^= b = con [a, b]

这样，任何属于CoherentModel的类型（包括Arrow a b）都会自动使用这个高效的con实现，除非你在Model实例里显式覆盖它。

对于Arrow类型，我们只需要定义CoherentModel实例，而Model实例会自动继承默认的高效实现：

data Arrow a b = [a] :->: b
lhs w = [ a | (u :->: _) <- w, a <- u ]
rhs w = [ b | (_ :->: b) <- w ]

-- 通用Model实例（当b不是CoherentModel时使用）
instance (Model a, Model b) => Model (Arrow a b) where
  con w = all (\w' -> con (lhs w') `implies` con (rhs w')) (powerset w)
    where
      implies p q = not p || q
      powerset [] = [[]]
      powerset (x:xs) = let ps = powerset xs in ps ++ map (x:) ps

-- 当b是CoherentModel时，CoherentModel实例会触发Model的默认高效实现
instance (Model a, CoherentModel b) => CoherentModel (Arrow a b) where
  (u :->: a) =^= (v :->: b) = con (u ++ v) `implies` a =^= b

这里的关键是：当Arrow a b满足CoherentModel约束时，Model的默认签名会优先使用高效版本；否则会使用你定义的通用Model实例。

解决方案2：重叠实例（Overlapping Instances） #

如果你不想修改超类的默认方法，可以通过开启FlexibleInstances和OverlappingInstances扩展，为Model (Arrow a b)写两个重叠的实例：一个更具体的（当b是CoherentModel时）使用高效实现，另一个通用的使用原始版本。

{-# LANGUAGE FlexibleInstances, OverlappingInstances #-}

-- 保持原来的Model和CoherentModel定义不变
class Model a where con :: [a] -> Bool
class Model a => CoherentModel a where
  (=^=) :: a -> a -> Bool
  a =^= b = con [a, b]

data Arrow a b = [a] :->: b
lhs w = [ a | (u :->: _) <- w, a <- u ]
rhs w = [ b | (_ :->: b) <- w ]

-- 更具体的实例：当b是CoherentModel时，使用高效con
instance (Model a, CoherentModel b) => Model (Arrow a b) where
  con = (all . uncurry) (=^=) . pairs
    where
      pairs [] = []
      pairs [_] = []
      pairs (x:xs) = map ((,) x) xs ++ pairs xs

-- 通用实例：当b不是CoherentModel时使用
instance (Model a, Model b) => Model (Arrow a b) where
  con w = all (\w' -> con (lhs w') `implies` con (rhs w')) (powerset w)
    where
      implies p q = not p || q
      powerset [] = [[]]
      powerset (x:xs) = let ps = powerset xs in ps ++ map (x:) ps

-- CoherentModel实例不变
instance (Model a, CoherentModel b) => CoherentModel (Arrow a b) where
  (u :->: a) =^= (v :->: b) = con (u ++ v) `implies` a =^= b

Haskell的类型系统会优先选择更具体的实例（即约束更强的那个），所以当b是CoherentModel时，会使用高效的con实现，否则使用通用版本。

注意事项 #

• 对于解决方案1，默认签名的约束必须是超类的子类（这里CoherentModel是Model的子类），这样才能保证类型安全。
• 重叠实例（解决方案2）需要谨慎使用，因为过度使用可能导致实例匹配的歧义，尤其是当你有更多复杂的类型嵌套时。
• 两种方法都需要开启对应的GHC扩展，记得在代码开头声明。

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