依赖类型是用在type class模式中的一种场景，当type class中存在多个类型参数时，某个类型参数可以由其他类型参数来决定。

这个概念是从shapeless作者的blog里看到的，依赖类型也是源自haskell的一种扩展

Functional dependencies are a near-standard extension to Haskell (present in GHC and elsewhere) which allow constraints on the type parameters of type classes to be expressed and then enforced by the compiler.They allow the programmer to state that some of the type parameters of a multi-parameter type class are completely determined by the others.

先看一下他举的例子，假设矩阵类型与矢量类型以及Int类型在做笛卡尔乘积运算时，结果类型取决于这两者的组合：

Matrix  *   Matrix  -> Matrix  //矩阵 * 矩阵 得到 矩阵
Matrix  *   Vector  -> Vector  //矩阵 * 矢量 得到 矢量
Matrix  *   Int     -> Matrix  //矩阵 * Int 得到 矩阵 
Int     *   Matrix  -> Matrix  //Int * 矩阵 得到 矩阵

因为结果类型受入参类型的约束，我们在设计函数时，可以把结果类型约束为满足这种组合的情况，用scala来实现

scala> trait Matrix 

scala> trait Vector

scala> trait MultDep[A, B, C] //定义一个笛卡尔运算时需要依赖类型，用于约束结果类型

我们通过隐式对象提供各种类型的组合时的依赖类型：

scala> implicit object mmm extends MultDep[Matrix, Matrix, Matrix]
scala> implicit object mvv extends MultDep[Matrix, Vector, Vector]
scala> implicit object mim extends MultDep[Matrix, Int, Matrix]
scala> implicit object imm extends MultDep[Int, Matrix, Matrix]

检验一下隐式对象：

scala> implicitly[MultDep[Matrix, Matrix, Matrix]] // OK: Matrix * Matrix -> Matrix
scala> implicitly[MultDep[Matrix, Vector, Vector]] // OK: Matrix * Vector -> Vector
scala> implicitly[MultDep[Matrix, Vector, Matrix]] // Error 没有定义过这种组合

现在在笛卡尔积的方法上增加这个隐式参数，来限制参数类型和结果类型必须符合我们的组合要求：

def mult[A, B, C](a : A, b : B)(implicit instance : MultDep[A, B, C]) : C =
{ 
    null.asInstanceOf[ C ]
}

这样我们在运行mult方法时，当传入的参数类型不符合我们用隐式对象提供的组合时，编译器直接会帮我们检查出来：

val r1 : Matrix = mult(new Matrix {}, new Matrix{}) // Compiles
val r2 : Vector = mult(new Matrix {}, new Vector{}) // Compiles
val r3 : Matrix = mult(new Matrix {}, 2)            // Compiles
val r4 : Matrix = mult(2, new Matrix {})            // Compiles
val r5 : Matrix = mult(new Matrix {}, new Vector{}) // 错误,结果类型应该是Vector

在scala的集合库中，当从一种类型的集合转换到另一种类型的集合时，比如执行map或to方法时会调用CanBuildFrom这个隐式参数来判断当前类型是否可转换为目标类型：

def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {
    val b = bf(repr)
    b.sizeHint(this)
    for (x <- this) b += f(x)
    b.result
}

这个CanBuildFrom type class 里面有三个类型参数：Repr, B, That

而这三个类型其实是有依赖的关系的，即 That 类型，是由Repr和B类型决定的：

// 由 List[_], String 构造 List[String]
scala> implicitly[CanBuildFrom[List[Int], String, List[String]]]

// 由 Set[_], Double 构造 Set[Double]
scala> implicitly[CanBuildFrom[Set[String], Double, Set[Double]]]

// 由 List[_], Int 构造的是 List[Int] 与 Set[String] 目标类型不一致
scala> implicitly[CanBuildFrom[List[String], Int, Set[Int]]]

// 由 List[_], Int 构造的是 List[Int] 与 List[Double] 目标类型不一致
scala> implicitly[CanBuildFrom[List[String], Int, List[Double]]]