类型类（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()
... ...
}
}
更完整的例子可以看这里。
