在scala世界，type classes是一种非常常见的模式，我们回顾一下scala库的实现中有哪些采用这种模式的

1) Ordering

scala> def foo[T:Ordering] (l:List[T]) { 
            l.sorted.foreach(print) 
        }

scala> foo(List(2,3,1))
123

Ordering[_]抽象了大于、等于、小于等用于比较的方法。它是一个典型的type class

2) Numeric

scala> def foo[T:Numeric] (l:List[T]) { 
            print(l.sum) // List只对数字类型才能使用sum方法
        }

scala> foo(List(1,2,3))
6

scala> def bar[T:Numeric](a:T, b:T) {
            implicitly[Numeric[T]].plus(a,b) 
        }

scala> bar(2,3)

Numeric[_]对抽象了所有数字类型中的加、减、乘、除等操作。

3) Manifest/TypeTag/ClassTag 等

scala> def biuldArray[T:ClassTag](len:Int) = new Array[T](len)

scala> buildArray[Int](3)
res8: Array[Int] = Array(0, 0, 0)

4) <:<[-From, +To], =:=[From,To]

scala> def test[T](i:T) (implicit ev: T <:< java.io.Serializable) { 
            print("OK") 
        }

不要被它的两个类型参数和中缀方式给迷惑，这两个用于类型证明的泛型类，使用上也属于type class模式

在《scala in depth》中总结了type classes模式的几个优点：

1) Separation of abstractions (抽象分离)
2) Composability (可组合)
3) Overridable (可覆盖)
4) Type safety (类型安全)

在进入主题之前，先了解一下通过泛型实现参数化多态的形式：

trait Comparable[T] { 
    def comp(o:T) = this.hashCode - o.hashCode 
}

class A extends Comparable[A] { 
    override def comp(o:A) = super.comp(o) 
}

class B(val i:Int) extends Comparable[B] { 
    override def comp(o:B) = this.i - o.i 
}

上面定义了一个Comparable的泛型特质，对于A,B等实现者可以设定不同的参数类型。

在scala里因为有隐式转换的功能，也可以在定义时不显式的继承Comparable特质，而在伴生对象里定义一个隐式转换，在需要用comp方法的时候，编译器会自动转换为目标类型：

scala> class A; 

scala> object A { 
            implicit def convert(a:A) : Comparable[A] = {
                new a.type with Comparable[A] { 
                    override def comp(o:A) = a.hashCode - o.hashCode 
                } 
            }
        }   

scala> a.comp(new A)
res2: Int = -1633174887

不过scala已经不鼓励使用隐式转换，必要的话，可以使用隐式参数：

// 需要定义一个新的comparable2特质，comp方法接受2个参数
scala> trait Comparable2[T] { def comp(x:A, y:A) = x.hashCode - y.hashCode } 

scala> class A; 

scala> object A { 
            implicit val compA = 
                new Comparable2[A] { override def comp(o:A) = super.comp(o) }
        }

上面定义了一个隐式参数compA它是Comparable[A]类型，不过这样如果要用到A的comp行为，需要在调用的方法中声明隐式参数

// 柯里化，最后一个参数是隐式的，编译器会自动在上下文找

scala> def call[T](x:T, y:T) (implicit c : Comparable2[T]) { 
            c.comp(x,y) 
        }

scala> val x = new A; val y = new A;

scala> call(x,y)

这样做相当于把A的结构与行为(方法)给分离开了(解耦)；或者说对某个类型，在不改动其本身的情况下，具备了扩展其行为的能力。

这个模式被称为type classes，源于haskell，我对haskell不熟悉，为什么用这么奇怪的一个名字？从这儿看到：在haskell里没有类似于java/scala里的class的概念，所以class这个术语可以随意使用，它的意思相当于”class of types”，可以理解为对某一系列类型的抽象(即高阶类型)。

scala里的type classes模式主要通过隐式参数来实现，但需要注意的是，并不是所有的隐式参数都可以理解为type classes模式，隐式参数的类型必须是泛型的(高阶)，它表示某种抽象行为，这种行为的具体实现要由它的具体类型参数决定。

// 隐式参数c在这里是多态的
scala> def call[T](x:T, y:T) (implicit c : Comparable2[T])

// 针对A实现了一个具体的comp行为，它的参数类型是A 
scala> implicit object CompA extends Comparable2[A] { 
            override def comp(x:A, y:A) = super.comp(x, y) 
        }

简单总结，type classes模式通过泛型来描述某种通用行为，对每个想要用到这种行为的具体类型，在现实时行为部分并不放在类型自身中，而是通过实现一个type class实例(对泛型具化)，最后在调用时(通过隐式参数)让编译器自动寻找行为的实现。

我们用类型证明来实现一个联合类型(union type):

// 让参数类型满足Int或String

scala> def f[A](a: A)(implicit ev: (Int with String) <:< A) = println("OK")
f: [A](a: A)(implicit ev: <:<[Int with String,A])Unit

scala> f(2) 
OK

scala> f("hi")
OK

跟我们之前通过context bound来是实现联合类型，对比一下更简洁。

对于类型限制 =:=和<:<

A =:= B  //表示A类型等同于B类型
A <:< B  //表示A类型是B类型的子类型

这个看上去很像操作符的=:= 和 <:<，实际是一个类，它在Predef里定义：

sealed abstract class =:=[From, To] extends (From => To) with Serializable

sealed abstract class <:<[-From, +To] extends (From => To) with Serializable

它定义了两个类型参数，所以可以使用中缀写法：From <:< To

2.10之前还有一个 <%< 类似于view bound，表示 A可以当作B，即A隐式转换成B也满足。但在2.10里已经废弃这种写法。

类型限制用在特定方法(specialized methods)的场景，所谓特定，是指方法只针对特定的类型参数才可以运行:

scala> def test[T](i:T)(implicit ev: T <:< java.io.Serializable) { print("OK") }
test: [T](i: T)(implicit ev: <:<[T,java.io.Serializable])Unit

scala> test("hi")
OK

scala> test(2)
<console>:9: error: Cannot prove that Int <:< java.io.Serializable.

上面定义的test方法，在方法的第二个参数使用了一个隐式参数ev，它的类型是：T <:< java.io.Serializable，表示只有参数类型T是java.io.Serializable的子类型，才符合类型要求。

或许你会奇怪上面test方法调用”hi”时，隐式参数ev是从哪儿传入的？当前并没有定义这个隐式参数。这个隐式参数也是由Predef里的隐式方法产生的

private[this] final val singleton_<:< = new <:<[Any,Any] { def apply(x: Any): Any = x }

implicit def conforms[A]: A <:< A = singleton_<:<.asInstanceOf[A <:< A]

当调用test("hi")，编译器推断出T是String，在寻找 String <:< java.io.Serializable类型的隐式参数时，上下文中找不到，于是通过conforms隐式方法来产生一个，conforms方法只有一个类型参数，它产生的结果是<:<[String,String]类型的对象，但因为<:<[-From,+To]第一个类型参数是逆变的，第二个类型参数是协变的，所以<:<[String,String]符合<:<[String,java.io.Serializable]的子类，满足要求。

而调用test(2)时，因为隐式方法产生的<:<[Int,Int]不符合<:<[Int,java.io.Serializable]子类型，抛出了异常。可见这块编译器是利用函数类型的多态机制来实现类型检测的。

另外，对于Type类型，在判断之间的关系时也有类似的写法，不过这里是Type类型的方法：

scala> typeOf[List[_]] =:= typeOf[List[AnyRef]]
res4: Boolean = false

scala> typeOf[List[Int]] <:< typeOf[Iterable[Int]]
res1: Boolean = true

上面的是方法调用：typ1.=:=(typ2) ，虽然效果都是证明类型关系，但不要混淆。

//2013.11.8 补充
昨天泽彬在csug的旺旺群(94329267/csugcsug)里问<:与<:<的差异：

object A{
    def test[T <: java.io.Serializable](i:T) {}
    test(1) // 编译时报错

    def test2[T](i:T)(implicit ev: T <:< java.io.Serializable)  {}
    test2(1) // 同样编译时报错
}

两者的效果似乎一样，应该怎么选择？他在stackoverflow上也问了一下：http://stackoverflow.com/questions/19829770/whats-different-between-and-in-scala

有人给出这样的解释：

def foo[A, B <: A](a: A, b: B) = (a,b)

scala> foo(1, List(1,2,3))
res1: (Any, List[Int]) = (1,List(1, 2, 3))

传入第一个参数是Int类型，第二个参数是List[Int]，显然这不符合 B <: A 的约束，编译器在做类型推导的时候，为了满足这个约束，会继续向上寻找父类型来匹配是否满足，于是在第一个参数被推导为Any类型的情况下，List[Int] 符合Any的子类型。

def bar[A,B](a: A, b: B)(implicit ev: B <:< A) = (a,b)

scala> bar(1,List(1,2,3))
<console>:9: error: Cannot prove that List[Int] <:< Int.

通过隐式参数ev来证明类型时，类型推断过程不会像上面那样再向上寻找可能满足的情况，而直接报错。

确实，在用 <: 声明类型约束的时候，不如用<:<更严格，除了上面的类型推导，存在隐式转换的情况下：

scala> def foo[B, A<:B] (a:A,b:B) = print("OK")

scala> class A; class B;

scala> implicit def a2b(a:A) = new B

scala> foo(new A, new B)  //存在A到B的隐式转换，也可满足
OK

scala> def bar[A,B](a:A,b:B)(implicit ev: A<:<B) = print("OK")

scala> bar(new A, new B)  //隐式转换并不管用
<console>:17: error: Cannot prove that A <:< B.

在java里，引用类型的数组类型是支持协变的，即 String[] 类型是 Object[] 的子类型，martin问过gosling，回答是希望有一个通用处理数组的简单方法。

void sort(Object[] a, Comparator cmp) { … }

数组的协变被用来确保任意参数类型的数组都可以传入排序方法。随着java引入了泛型，sort方法可以用类型参数，因此数组的协变不再有用。只是考虑到兼容性。

scala里不支持数组的协变，以尝试保持比java更高的纯粹性。即 Array[String]的实例对象不能赋给Array[Any]类型的变量。

在数组的设计上，scala是走过弯路的，这里有篇文章翻自martin写的关于scala2.8数组的paper，已经解释的非常好了。

正是因为2.8中的数组背后的实现要与java保持一致，使得通过泛型创建某个数组时

def test[T]() {
    val a = new Array[T] //运行时类型缺失，无法创建对应的java数组
}

因为java里的数组，实际会对应int[],float[],char[],等8个基础类型数组，与1个支持协变的引用类型数组。

更细的看一下java引用类型的数组类型：

scala> class A { 
|       val a1 = new Array[java.lang.Object](1);
|       val a2 = new Array[String](1);
| }

scala> :javap A    
...
//  a1:[Ljava/lang/Object;
...
//  a2:[Ljava/lang/String;

看到String[]会被编译器翻译为[Ljava/lang/String，而Object[]被翻译为[Ljava/lang/Object，其实可以看做是一种泛型类型的特例，[L 是类型构造器，String、Object 等是类型参数。但不同于java里其他泛型集合的实现，数组类型中的类型参数在运行时是必须的，即 [Ljava/lang/String 与 [Ljava/lang/Object 是两个不同的类型，不像 Collection<String> 与 Collection<StringBuilder> 运行时参数类型都被擦拭掉，成为Collection<Object>。

为此，2.8中不得不引入了Manifest来保存T在运行时的类型信息(参考上一篇对Manifest与TypeTag的介绍)，从而保证运行时scala数组与java的数组实现一致。