黑猴子的家：Scala Manifest 上下文界定

Manifest是scala2.8引入的一个特质，用于编译器在运行时也能获取泛型类型的信息。在JVM上，泛型参数类型T在运行时是被“擦拭”掉的，编译器把T当作Object来对待，所以T的具体信息是无法得到的；为了使得在运行时得到T的信息，scala需要额外通过Manifest来存储T的信息，并作为参数用在方法的运行时上下文。
def test[T] (x:T, m:Manifest[T]) { ... }
有了Manifest[T]这个记录T类型信息的参数m，在运行时就可以根据m来更准确的判断T了。但如果每个方法都这么写，让方法的调用者要额外传入m参数，非常不友好，且对方法的设计是一道伤疤。好在scala中有隐式转换、隐式参数的功能，在这个地方可以用隐式参数来减轻调用者的麻烦。

保存被擦除的泛型信息

1、判断泛型类型

Manifestdef foo[T](x: List[T])(implicit m: Manifest[T]) = {
  println(m) 
  //如果这个m是这个清单类型的话，或者说，如果这个m是String类型的话，那么就打印 Hey…
  if (m <:< manifest[String])
    println("Hey, this list is full of strings")
  else
    println("Non-stringy list")
}

foo(List("one", "two"))
foo(List(1, 2))
foo(List("one", 2))

隐式参数m是由编译器根据上下文自动传入的，比如上面是编译器根据 "one","two" 推断出 T 的类型是 String，从而隐式的传入了一个Manifest[String]类型的对象参数，使得运行时可以根据这个参数做更多的事情。
不过上面的foo 方法定义使用隐式参数的方式，仍显得啰嗦，于是scala里又引入了“上下文绑定”，
def foo[T](x: List[T]) (implicit m: Manifest[T])
可以简化为：
def foo[T:Manifest] (x: List[T])
在引入Manifest的时候，还引入了一个更弱一点的ClassManifest，所谓的弱是指类型信息不如Manifest那么完整，主要针对高阶类型的情况
scala在2.10里却用TypeTag替代了Manifest，用ClassTag替代了ClassManifest，原因是在路径依赖类型中，Manifest存在问题
TypeTag 是个什么东西呢？是一个容器，类似于 TypeTag[Type[Int] , Type[String] , Type[Dog]]

def foo[T](x: List[T]) (implicit m: Manifest[T]) 这句话怎么解读呢？我想foo函数传入一个类型器，或者这个类型器我不传，然后我传一个参数，根据这个参数我推断这个类型器，推断出来后，我在编译的时候，我把参数所对应的这个类型器元数据信息存在Manifest[T]里面，是这样一个描述的过程，可以简化为def foo[T:Manifest] (x: List[T]) ，意思是一样的，我传入一个类型T,这个类型T直接存入到类型清单里面Manifest,那么这个T，我们可以理解为清单类型，def foo[T:Manifest] (x: List[T]) 是 def foo[T](x: List[T]) (implicit m: Manifest[T]) 的简化，所以我们不能直接读这个T 是清单类型

类也是对象，对象只能通过对象来创建
class Dog{}
val dog = new Dog
dog.getClass() Dog.class
Dog.class dog = new Type(Dog.class)
//不要再往下推理了，上帝说有光，所以有了光
Type type = new Type()

2、简提隐士转换

object Pair7 {
  def main(args: Array[String]): Unit = {
    //隐士转化不能出现二义性
    implicit val aaa:Int = 10
    //implicit val bbb:Int = 32
    def play(implicit x:Int): Unit ={
      println(x)
    }
    play
  }
}

3、Manifest

scala> class Foo{class Bar}
defined class Foo

scala> def m(f: Foo)(b: f.Bar)(implicit ev: Manifest[f.Bar]) = ev
m: (f: Foo)(b: f.Bar)(implicit ev: Manifest[f.Bar])Manifest[f.Bar]

scala> val f1 = new Foo;val b1 = new f1.Bar
f1: Foo = Foo@681e731c
b1: f1.Bar = Foo$Bar@271768ab

scala> val f2 = new Foo;val b2 = new f2.Bar
f2: Foo = Foo@3e50039c
b2: f2.Bar = Foo$Bar@771d16b9

scala> val ev1 = m(f1)(b1)
ev1: Manifest[f1.Bar] = Foo@681e731c.type#Foo$Bar

scala> val ev2 = m(f2)(b2)
ev2: Manifest[f2.Bar] = Foo@3e50039c.type#Foo$Bar

scala> ev1 == ev2 
res28: Boolean = true

4、TypeTag

class Animal{}
class Dog extends Animal{}

object MainFoo extends App{
  override def main(args: Array[String]): Unit = {
    val list1 = List(1, 2, 3)
    val list2 = List("1", "2", "3")
    val list3 = List("1", "2", 3)

    def test1(x: List[Any]) = {
      x match {
        case list: List[Int] => "Int list"
        case list: List[String] => "String list"
        case list: List[Any] => "Any list"
      }
    }
    println(test1(list1))
    println(test1(list2))
    println(test1(list3))

    import scala.reflect.runtime.universe._
    // typeOf[A] 拿到类对象的描述信息
    def test2[A : TypeTag](x: List[A]) = typeOf[A] match {
      case t if t =:= typeOf[String] => "String List"
      case t if t <:< typeOf[Animal] => "Dog List"
      case t if t =:= typeOf[Int] => "Int List"
    }

    println(test2(List("string")))
    println(test2(List(new Dog)))
    println(test2(List(1, 2)))
  }
}

尖叫提示：=:=，意思为：类型相等type equality
<:< ,意思为：子类型关系subtype relation
类型判断不要用 == 或 !=

简单理解 typeOf[A]
val animal = new Ainmal
通过 animal 这个对象对应的描述信息是“class Animal”
“class Animal” 这个对象的描述信息是 Type[Animal]