Haskell 类型类：class 与 instance

Haskell 的类型系统通过“类型类（type class）”实现类似其他语言中“接口”或“泛型约束”的功能。类型类定义了一组函数的契约，而具体类型通过 instance 声明来实现这些函数。理解 class 和 instance 是掌握 Haskell 多态编程的关键。

定义一个类型类

使用 class 关键字定义类型类，并指定该类支持的操作。

1. 编写 类声明，以 class 开头，后跟类名和类型变量。
   例如，定义一个名为 Describable 的类型类，要求实现一个返回字符串描述的函数：

class Describable a where
  describe :: a -> String

这里 a 是一个类型变量，表示任何属于 Describable 类的类型。

2. 可选地提供默认实现（但必须至少有一个无默认的函数）。
   例如，为 describe 添加一个默认行为（虽然本例不需要）：

class Describable a where
  describe :: a -> String
  describe _ = "No description available"

如果某个 instance 没有显式定义 describe，就会使用这个默认值。

为具体类型实现类型类

使用 instance 关键字为已有类型实现类型类。

1. 选择 一个具体类型（如 Bool、自定义数据类型等）。
2. 编写 instance 声明，指定类型和类，并实现所有必需的函数。

例如，让 Bool 成为 Describable 的实例：

instance Describable Bool where
  describe True  = "It's true!"
  describe False = "It's false!"

现在你可以调用 describe True，结果是 "It's true!"。

使用类型类约束函数

在函数签名中使用类型类作为约束，限制参数类型必须属于某类。

1. 在 => 左侧写约束，右侧写正常类型签名。

例如，编写一个通用打印函数：

printDescription :: Describable a => a -> IO ()
printDescription x = putStrLn (describe x)

这表示：只要 a 是 Describable 的实例，就可以传入 printDescription。

2. 调用时自动匹配实例。
   执行 printDescription True 会输出 "It's true!"，因为 Bool 已有 Describable 实例。

自定义数据类型与实例

先定义数据类型，再为其创建实例。

1. 定义 一个新类型。例如，表示二维点：

data Point = Point Float Float

2. 为该类型实现 instance：

instance Describable Point where
  describe (Point x y) = "Point at (" ++ show x ++ ", " ++ show y ++ ")"

注意：这里用到了 show，所以 Float 必须属于 Show 类（它确实属于）。

3. 测试使用：

main = printDescription (Point 1.5 2.0)
-- 输出: Point at (1.5, 2.0)

标准库中的常见类型类

Haskell 预定义了许多常用类型类。以下是几个核心示例：

例如，为 Point 实现 Eq：

instance Eq Point where
  (Point x1 y1) == (Point x2 y2) = x1 == x2 && y1 == y2

一旦实现了 Eq，你就可以用 == 比较两个 Point。

自动派生（deriving）

对简单类型，可用 deriving 自动生成标准类的实例。

1. 在 data 声明末尾添加 deriving 子句。

例如：

data Color = Red | Green | Blue deriving (Eq, Show)

这会自动为 Color 生成 Eq 和 Show 的合理实现。

2. 验证效果：

Red == Green  -- 返回 False
show Blue     -- 返回 "Blue"

注意：deriving 仅适用于结构简单的类型，且仅支持特定类型类（如 Eq、Ord、Show 等）。

多参数与关联类型（进阶）

某些类型类涉及多个类型，或通过“关联类型”绑定依赖关系。

1. 启用扩展（需在文件顶部添加编译器指令）：

{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FunctionalDependencies #-}

2. 定义多参数类。例如，表示“容器”与其元素的关系：

class Container c e | c -> e where
  contains :: c -> e -> Bool

c -> e 表示：给定容器类型 c，元素类型 e 被唯一确定。

3. 实现实例：

instance Container [a] a where
  contains = elem

现在 contains [1,2,3] 2 返回 True。

常见错误与排查

1. 忘记实现所有函数：
   编译器会报错“No instance for ...”或“Missing methods”。检查 instance 是否覆盖了 class 中所有无默认实现的函数。

2. 类型不匹配：
   在 instance 中，函数签名必须与 class 中完全一致。确保参数和返回类型与类定义吻合。

3. 孤儿实例（Orphan Instance）警告：
   如果 instance 定义既不在类型定义处，也不在类定义处，GHC 会警告。最佳实践：将 instance 写在定义类型或类的同一模块中。

4. 重叠实例（Overlapping Instances）：
   当多个 instance 可能匹配同一类型时，编译器无法决定用哪个。避免定义过于宽泛的实例（如 instance Describable a），除非明确需要并启用相关扩展。

实战：实现一个简易 JSON 序列化类

1. 定义类型类：

class ToJSON a where
  toJSON :: a -> String

2. 为基本类型实现实例：

instance ToJSON Bool where
  toJSON True  = "true"
  toJSON False = "false"

instance ToJSON Int where
  toJSON n = show n

instance ToJSON String where
  toJSON s = "\"" ++ escape s ++ "\""
    where
      escape = concatMap (\c -> case c of
                                '"' -> "\\\""
                                '\\' -> "\\\\"
                                '\n' -> "\\n"
                                _ -> [c])

3. 为列表实现泛型实例（需启用 FlexibleInstances）：

{-# LANGUAGE FlexibleInstances #-}

instance ToJSON a => ToJSON [a] where
  toJSON xs = "[" ++ intercalate "," (map toJSON xs) ++ "]"
    where
      intercalate sep = concat . intersperse sep
      intersperse _ [] = []
      intersperse _ [x] = [x]
      intersperse sep (x:xs) = x : sep : intersperse sep xs

4. 测试：

toJSON [True, False]   -- "[true,false]"
toJSON ["a\nb"]        -- "[\"a\\nb\"]"

这展示了如何用类型类构建可扩展的序列化系统。