Scala设计模式：类型类模式（Type Classes Pattern）

类型类（type classes）是类型系统中的一种结构，可以用来实现即席多态（ad-hoc polymorphism)。最早出现在Haskell语言中，用于定义通用接口，使接口可以操作各种不同的类型。Scala中，也大量使用了这种模式，比如库中的Ordering、Numeric的都用了类型类模式。

什么是类型类模式（Type Classes Pattern）？

类型类模式就是实现即席多态的一种模式。要搞清楚类型类模式，得先回顾一下多态。多态（Polymorphism）是现在高级语言中一个重要的特性，程序在运行时，根据具体类型的不同，表现出不同的行为。它使得我们可以面向接口编程，写出更通用、重用性更高的代码。多态可以分为三种：

• 子类型多态（通过抽象类实现）
• 参数化多态（通过泛型实现）
• 即席多态（通过类型类实现）

为了搞清楚几种多态的差别，我们举个例子：现在有个Human，他有个sayHelloTo的方法，可以向小猫、小狗打招呼，并且得到他们的回应。

1. 没有多态：在没有多态时，我们要给每种动物分别定义一个接口，如下：

class Human {
  def sayHelloTo(cat: Cat): String = 
    s"Human say hello, get reply: ${cat.say()}"

  def sayHelloTo(dog: Dog): String = 
    s"Human say hello, get reply: ${dog.say()}"
}

class Cat {
  def say(): String = "meow"
}

class Dog {
  def say(): String = "woof"
}

这里，sayHelloTo定义了两次，而且以后每增加一种小动物，我们都要新增一个新的sayHelloTo的方法，这一点也不通用！

2. 子类型多态：为了使程序更通用化，我们可以定义一个抽象的接口Animal，Human只与Animal打交道，而具体的不同动物可以有不同的行为。

class Human {
  def sayHelloTo(animal: Animal): String = 
    s"Human say hello, get reply: ${animal.say()}"
}

trait Animal {
  def say(): String
}

class Cat extends Animal {
  override def say(): String = "meow"
}

class Dog extends Animal {
  override def say(): String = "woof"
}

这样，Human可以与任何Animal的子类型打招呼了。

3. 参数化多态：现在需求发生变化了，Human不只可以与Animal打招呼，还可以与更多的东西打招呼，比如：“向天空大声的呼唤说声我爱你，向那流浪的白云说声我想你……”。而且，每种东西说出来的类型也不一样，比如动物说出来的是Sound，大自然说出来的是SweetWord。怎样才能让接口更加通用呢？——这里我们可以用泛型，抽象出更通用的Speakable[T]接口：

class Human {
  def sayHelloTo[T](target: Speakable[T]): String = 
    s"Human say hello, get reply: ${target.say()}"
}

trait Speakable[T] {
  def say(): T
}

/* 会发出叫声的动物 */
case class Sound(msg: String)

trait Animal extends Speakable[Sound]

class Cat extends Animal {
  override def say(): Sound = Sound("meow")
}

class Dog extends Animal {
  override def say(): Sound = Sound("woof")
}

/* 会说蜜语的大自然 */
case class SweetWord(msg: String)

trait Nature extends Speakable[SweetWord]

class Sky extends Nature {
  override def say(): SweetWord = SweetWord("I love you")
}

class Cloud extends Nature {
  override def say(): SweetWord = SweetWord("I miss you")
}

这样，Human可以和任何具有Speakable能力的东西打招呼了，也能得到他们不同类型的回应。

4. 即席多态：前面两种多态，都需要设计类的时候就支持相应的接口。如果一切都能一开始就设计好，那就什么事儿都没有了。可现实往往不是这样。如果最开始设计Animal和Nature的时候，并没想到他们要实现Speakable接口呢？如何能在不改原有设计的情况下，给他们动态添加上say()方法，并且Human还能向他们sayHelloTo呢？——这就需要类型类这种机制了。Scala中类型类这种机制可以通过隐式参数和隐式对象来实现。

class Human {
  // 使用隐式参数将target隐式转换为Speakable
  def sayHelloTo[A](target: A)(implicit s: Speakable[A]): String = 
    s"Human say hello, get reply: ${s.say()}"
}

trait Speakable[T] {
  def say(): String
}

/* 动物定义的时候并不支持say */
trait Animal
class Cat extends Animal
class Dog extends Animal

/* 定义隐式对象 */
implicit object SpeakableCat extends Speakable[Cat] {
    override def say(): String = "meow"
}

implicit object SpeakableDog extends Speakable[Dog] {
    override def say(): String = "woof"
}

这样，Human就有了高度通用的sayHelloTo方法，可以对任何对象打招呼了。这就是类型类模式。

类型类模式的做法

把上面实现的类型类模式的例子抽象一下，其结构如下：

• TypeClass[A]是一个范型，定义了一个接口，型如：

trait TypeClass[A] {
  def operation()
}

• 对于每个Target类，定义其对应的ImplicitObject，型如：

implicit object ImplicitObject1 extends TypeClass[Target1] {
    override def operation() = ???  // 具体实现
}

• 在Client中，定义一个含有TypeClass[A]隐式参数的方法，这样定义的方法，可以操作任何类型的Target（只要该Target有对应的ImplicitObject），具有更高的通用性。型如：

class Client {
  def func[A](target: A)(implicit tc: TypeClass[A]) = {
    tc.operation()
    ... ...
  }
}

更完整的例子可以看这里。