Haskell多构造器类型：仅自定义C构造器Eq/Ord逻辑的技巧咨询

当然有办法！你可以通过分离自动推导逻辑和自定义逻辑的方式，彻底避免重复编写A、B构造器的样板代码。核心思路是把不需要自定义的构造器（A、B）抽出来，让Haskell自动推导它们的Eq/Ord实例，然后在原类型的实例中复用这些自动生成的逻辑，只专注处理C构造器的特殊规则。

方案1：基础版（无额外扩展依赖） #

这种方法不需要启用复杂扩展，用最基础的Haskell语法就能实现：

首先定义一个只包含A、B的辅助类型，让Haskell自动推导它的Eq和Ord实例：

-- 辅助类型：仅包含需要自动推导的构造器
data FooAB a = AB_A a | AB_B Int deriving (Eq, Ord)

-- 原类型保持不变
data Foo a = A a | B Int | C a (a -> Bool)

-- 辅助函数：将Foo转换为FooAB（仅支持A、B构造器）
toFooAB :: Foo a -> Maybe (FooAB a)
toFooAB (A x) = Just (AB_A x)
toFooAB (B x) = Just (AB_B x)
toFooAB _ = Nothing

接下来实现Eq实例，完全复用FooAB的自动推导逻辑处理A、B，只自定义C的规则：

instance Eq a => Eq (Foo a) where
  x == y = case (toFooAB x, toFooAB y) of
    -- 两个都是A/B？直接用自动推导的Eq逻辑
    (Just abX, Just abY) -> abX == abY
    -- 两个都是C？用你自定义的相等规则
    (Nothing, Nothing) -> let (C x f, C y g) = (x, y) in x == y && f x == g y
    -- 一个是A/B，一个是C？直接不相等
    _ -> False

然后是Ord实例，同样复用FooAB的自动排序逻辑，只处理C的特殊情况和构造器优先级：

instance Ord a => Ord (Foo a) where
  compare x y = case (toFooAB x, toFooAB y) of
    -- 两个都是A/B？用自动推导的Ord逻辑
    (Just abX, Just abY) -> compare abX abY
    -- A/B和C比较：按照你原来的规则，A/B < C
    (Just _, Nothing) -> LT
    (Nothing, Just _) -> GT
    -- 两个都是C？用你自定义的排序规则
    (Nothing, Nothing) -> let (C x f, C y g) = (x, y) in
                          if x == y then compare (f x) (g y) else compare x y

这样一来，A、B构造器的所有比较逻辑都交给Haskell自动生成，你只需要维护C构造器的规则，完全告别繁琐的样板代码。

方案2：进阶版（用DerivingVia简化） #

如果你愿意启用DerivingVia扩展，可以让代码更简洁——甚至不需要手动定义辅助类型的构造器，直接复用Haskell内置类型的实例：

首先启用必要的扩展：

{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE FlexibleInstances #-}

然后定义原类型和包装辅助类型：

data Foo a = A a | B Int | C a (a -> Bool)

-- 包装类型：用于复用自动推导逻辑
newtype FooAB a = FooAB (Foo a)

-- 利用Either的Eq/Ord实例推导FooAB的实例（A对应Left a，B对应Right Int，正好符合默认排序逻辑）
deriving via (Either a Int) instance Eq a => Eq (FooAB a)
deriving via (Either a Int) instance Ord a => Ord (FooAB a)

-- 辅助函数：安全转换为FooAB
toFooAB :: Foo a -> Maybe (FooAB a)
toFooAB foo@(A _) = Just (FooAB foo)
toFooAB foo@(B _) = Just (FooAB foo)
toFooAB _ = Nothing

之后的Eq和Ord实例写法和方案1完全一致，但辅助类型的定义更简洁，不需要手动写构造器。

核心优势 #

两种方案都遵循同一个原则：把通用逻辑交给自动推导，只处理特殊情况。这样既保留了Haskell自动推导的便利性，又能灵活实现自定义规则，同时彻底避免了重复编写样板代码的麻烦。

内容的提问来源于stack exchange，提问作者Mathias Vorreiter Pedersen