为同一数据类型的不同构造器指定不同最小完整定义

这确实是Haskell类型类使用中很常见的一个痛点——当你的数据类型有多个构造器，每个构造器对应类型类方法的最优实现路径不一样时，直接用默认推导要么效率不高，要么会写出大量重复代码。下面给你几个实用的解决思路：

思路1：在实例中通过模式匹配复用默认推导逻辑 #

你可以在apply和fill方法里分别对不同构造器做模式匹配，对于每个构造器，只实现它的最优方法，另一个方法直接复用类型类里已经定义好的默认推导逻辑。这样既避免了重复代码，又保证了每个构造器都用最有效的实现：

instance Transforming SimpleTransform where
  -- 对于SingletonTrans，复用fill的实现来推导apply
  apply trans@(SingletonTrans _) = fill trans . singleton
  -- 对于GenericTrans，直接用构造器自带的函数实现apply
  apply (GenericTrans f) = f

  -- 对于GenericTrans，复用apply的实现来推导fill
  fill trans@(GenericTrans _) = foldr union empty . map (apply trans)
  -- 对于SingletonTrans，直接用map实现高效的fill
  fill (SingletonTrans f) = map f

这里的trans@(...)语法是为了在调用默认逻辑时，能把整个构造器实例传递给另一个方法，完全复用类型类里已经写好的推导代码，不用自己重复写一遍。

思路2：拆分数据类型，让每个构造器对应独立的子类型 #

如果你的构造器逻辑差异较大，或者以后可能扩展更多构造器，更优雅的方式是把不同构造器拆成独立的新类型，分别实现Transforming实例，最后再用一个sum类型把它们组合起来：

-- 拆分出独立的子类型
newtype SingletonTrans a = SingletonTrans (a -> a)
newtype GenericTrans a = GenericTrans (a -> Set a)

-- 为每个子类型实现最小定义
instance Transforming SingletonTrans where
  fill (SingletonTrans f) = map f
  -- apply会自动使用类型类的默认推导

instance Transforming GenericTrans where
  apply (GenericTrans f) = f
  -- fill会自动使用类型类的默认推导

-- 组合成原来的sum类型
data SimpleTransform a = STSingleton (SingletonTrans a) | STGeneric (GenericTrans a)

-- 转发调用子类型的实例方法
instance Transforming SimpleTransform where
  apply (STSingleton st) = apply st
  apply (STGeneric gt) = apply gt
  fill (STSingleton st) = fill st
  fill (STGeneric gt) = fill gt

这种方式的好处是每个子类型的职责单一，实例实现非常简洁，以后新增构造器时，只需要加对应的子类型和实例，sum类型的实例只需要多一个分支即可，扩展性拉满。

思路3：提取Helper函数简化实例代码 #

如果某些构造器的实现逻辑比较复杂，你可以把它们提取到顶层的helper函数中，然后在实例里直接调用，让实例代码更整洁：

-- 提取SingletonTrans的fill实现
fillSingleton :: Ord a => (a -> a) -> Set a -> Set a
fillSingleton = map

-- 提取GenericTrans的apply实现
applyGeneric :: Ord a => (a -> Set a) -> a -> Set a
applyGeneric = id

instance Transforming SimpleTransform where
  apply (SingletonTrans f) = fill (SingletonTrans f) . singleton
  apply (GenericTrans f) = applyGeneric f
  fill (SingletonTrans f) = fillSingleton f
  fill (GenericTrans f) = foldr union empty . map (apply (GenericTrans f))

这种方式和思路1本质类似，但把复杂逻辑抽离后，实例代码更易读，也方便单独测试这些helper函数。

总结 #

• 如果你的构造器数量不多，逻辑也不复杂，思路1是最直接高效的选择；
• 如果以后有扩展需求，或者每个构造器的逻辑差异较大，思路2更符合Haskell的设计哲学，代码可维护性更好；
• 若存在复杂的实现逻辑，思路3可以让你的实例代码保持简洁。

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