类型类（Typeclasses）与法则约束¶

标准库类型类的层级¶

标准库中的类型类构成两棵依赖树。实线箭头表示“子类要求先实现父类”，虚线表示常见的实例类型。第一棵描述单个值的能力，比较、枚举、算术：

        graph TD
  Eq["Eq<br/>(==), (/=)"] --> Ord["Ord<br/>compare, (<), (<=)"]
  Show["Show<br/>show"]
  Read["Read<br/>read"]
  Enum["Enum<br/>succ, pred, toEnum"]
  Bounded["Bounded<br/>minBound, maxBound"]

  Num["Num<br/>(+), (-), (*)"] --> Real["Real<br/>toRational"]
  Num --> Fractional["Fractional<br/>(/), fromRational"]
  Real --> Integral["Integral<br/>div, mod, toInteger"]
  Real --> RealFrac["RealFrac<br/>truncate, round, floor"]
  Fractional --> RealFrac
  Fractional --> Floating["Floating<br/>sin, exp, sqrt, log"]
  RealFrac --> RealFloat["RealFloat<br/>isNaN, isInfinite"]
  Floating --> RealFloat

  Int([Int]) -.实例.-> Integral
  Integer([Integer]) -.实例.-> Integral
  Float([Float]) -.实例.-> RealFloat
  Double([Double]) -.实例.-> RealFloat

  classDef inst fill:#f4f4f4,stroke:#999,stroke-dasharray: 4 2;
  class Int,Integer,Float,Double inst;
    

第二棵描述“容器”和“带效果的计算”的能力：合并、映射、组合、遍历。这些是第四部分的主题，现在只需要知道它们之间的关系：

        graph TD
  Semigroup["Semigroup<br/>(<>)"] --> Monoid["Monoid<br/>mempty, mconcat"]

  Functor["Functor<br/>fmap, (<$>)"] --> Applicative["Applicative<br/>pure, (<*>)"]
  Applicative --> Monad["Monad<br/>(>>=), return"]
  Applicative --> Alternative["Alternative<br/>empty, (<|>)"]
  Monad --> MonadFail["MonadFail<br/>fail"]
  Monad --> MonadIO["MonadIO<br/>liftIO"]

  Foldable["Foldable<br/>foldr, foldMap, toList"] --> Traversable["Traversable<br/>traverse, sequenceA"]
  Functor --> Traversable

  List(["[a]"]) -.实例.-> Monoid
  List -.实例.-> Alternative
  List -.实例.-> Traversable
  Maybe(["Maybe a"]) -.实例.-> Alternative
  Maybe -.实例.-> Traversable
  IO(["IO a"]) -.实例.-> MonadIO
  Text(["Text / ByteString"]) -.实例.-> Monoid
  Map(["Map k v"]) -.实例.-> Monoid
  Map -.实例.-> Traversable

  classDef inst fill:#f4f4f4,stroke:#999,stroke-dasharray: 4 2;
  class List,Maybe,IO,Text,Map inst;
    

图中的方框都是类型类，Int、Maybe a 这样的具体类型是它们的实例，而不是子类。Ord 的实例必须先是 Eq 的实例，Monad 的实例必须先是 Applicative 和 Functor 的实例，依此类推。注意第二棵树里的类型类约束的是类型构造器：Functor 的实例是 Maybe 而不是 Maybe Int，是 [] 而不是 [Int]。这是 Text 能是 Monoid 却不能是 Functor 的原因：它不装别的类型的值。

下表是常见类型各自实现了哪些类型类。空格表示没有实例，括号内是附加条件：

String 就是 [Char]，所以列表那一行的能力它全都有，第二行是把它和 Text 放在一起看作“文本”时的常用视角。

社区里的知名类型类¶

第三方库沿用同一套机制：定义一个类型类，说明“你的类型只要能做这件事，就能用我的全部功能”。下面是最常遇到的几个：

还有两个著名的库值得单独说，因为它们的核心不是新的类型类，而是直接建立在标准类型类之上：

• lens：一个 Lens' s a 的定义是 forall f. Functor f => (a -> f a) -> s -> f s，也就是一个对任意 Functor 都成立的函数。读取时把 f 选成 Const，修改时选成 Identity，遍历多个位置的 Traversal 则把 Functor 换成 Applicative。正因为 lens 只是函数，它们才能用普通的 . 组合。库里另外有 Ixed（ix）、At（at）、Each（each）这样的类型类，为列表、Map、元组统一提供“按下标访问”和“遍历每个元素”。

• conduit：流处理的每一段 ConduitT i o m r 都是 Functor、Applicative、Monad、MonadIO 的实例。所以写一个处理阶段就是写 do 块，里面可以用 liftIO、when、forever、mapM_。库自己只新增了把阶段串起来的 .| 和 await、yield 几个原语。

命令行一章介绍的 optparse-applicative 也是同样的思路：库只定义 Parser a 并为它实现 Applicative 和 Alternative，组合选项用的是标准的 <$>、<*> 和 <|>。学会标准类型类，就等于学会了这些库的大半用法。

Eq（等价性）¶

提供相等比较 (==) 与不等比较 (/=)：

class Eq a where
  (==), (/=) :: a -> a -> Bool
  x == y = not (x /= y)
  x /= y = not (x == y)
  {-# MINIMAL (==) | (/=) #-}

Eq 法则：

1. 自反性（Reflexivity）：x == x = True

2. 对称性（Symmetry）：x == y 与 y == x 结果必须相同。

3. 传递性（Transitivity）：若 x == y && y == z 为真，则 x == z 必为真。

4. 代换性（Substitutability）：若 x == y，则对任意纯函数 f，必有 f x == f y。

Ord（全序比较）¶

继承自 Eq，提供大小比较。核心方法是三态比较函数 compare :: Ord a => a -> a -> Ordering（返回 LT、EQ 或 GT）：

class Eq a => Ord a where
  compare :: a -> a -> Ordering
  (<), (<=), (>), (>=) :: a -> a -> Bool
  max, min :: a -> a -> a
  {-# MINIMAL compare | (<=) #-}

Ord 法则：

1. 自反性：x <= x = True

2. 反对称性（Antisymmetry）：若 x <= y && y <= x，则 x == y。

3. 传递性：若 x <= y && y <= z，则 x <= z。

4. 完全可比性（Totality）：对任意 x 与 y，必有 x <= y || y <= x = True。

Bounded 与 Enum¶

• Bounded：定义具有明确上限与下限的类型：

  class Bounded a where
    minBound :: a
    maxBound :: a
  

• Enum：定义元素可与连续整数一一对应的顺序枚举类型：

  • succ :: Enum a => a -> a：后继元素。

  • pred :: Enum a => a -> a：前驱元素。

  • toEnum :: Enum a => Int -> a 与 fromEnum :: Enum a => a -> Int。

Show 与 Read（文本序列化往返）¶

• Show：提供 show :: Show a => a -> String，生成文本表示。

• Read：提供 read :: Read a => String -> a，从文本解析值。

往返法则（Roundtrip Law）：

read (show x) == x

基本自动派生¶

对于标准类型类，GHC 能够根据数据结构自动生成实例代码：

data Priority = Low | Medium | High
  deriving (Eq, Ord, Show, Read, Enum, Bounded)

只需一行，Priority 即可直接排序、打印和遍历：

ghci> Low < High
True
ghci> minBound :: Priority
Low
ghci> succ Low
Medium
ghci> [Low .. High]
[Low,Medium,High]

泛化 newtype 派生（GeneralizedNewtypeDeriving）¶

如果我们用 newtype 包装了一个底层类型，开启这个语言扩展后，编译器可以直接复用底层类型的实例：

{-# LANGUAGE GeneralizedNewtypeDeriving #-}

newtype Score = Score Int
  deriving (Eq, Ord, Show, Num)

ghci> Score 80 + Score 15
Score 95