【2019-06-05】隐式转换和参数

隐式转换
scala里一个核心集合特质是RandomAccessSeq[T]，描述了建立在类型T的元素上的随机访问序列

//定义从 string 到实际为RandomAccessSeq
object String2Seq {
  implicit def stringWrapper(s: String) = 
    new RandomAccessSeq[Char] {
      def length = s.length
      def apply(i: Int) = s.charAt(i)
    }

  def printWithSpaces(seq: RandomAccessSeq[Char]) = 
    seq mkString " "
}

隐式操作规则
隐式定义是指是为了修正类型错误而允许插入到程序中的定义。
隐式转换由以下通用规则掌控：
标记规则：只有标记为implicit的定义是可用的
作用域规则：插入的隐式转换必须以单一标识符的形式处于作用域中，或与转换的源或目标类型关联在一起。
无歧义规则：隐式转换唯有不存在其他可插入转换的前提下才能插入。
单一调用规则：只会尝试一个隐式操作。
命名隐式转换：隐式转换可以任意命名。
隐式转换在哪里尝试：转换为期望类型、指定（方法）调用者的转换、隐式参数。

隐式转换为期望类型是编译器会使用隐式操作的第一个地方，一旦编译器看到了X，但需要Y，就会检查从X到Y的隐式转换函数。

object Obj1{
      implicit def intToString(x:Int)=x.toString
      implicit def int2double(x:Int):Double=x.toDouble
      val aMap=Map(1->"one",2->"two",3->"three")
//带有上界的函数
      def maxListUpBound[T<:Ordered[T]](elements:List[T]):
      T=elements match {
      case List()=>throw new IllegalArgumentException("empty list!")
      case List(x)=>x
      case x::rest=>val maxRest = maxListUpBound(rest)
      if (x>maxRest) x
      else maxRest
      }
//使用了内部隐式参数的函数
      def maxList[T](elements:List[T])(
      implicit ordered:T=>Ordered[T]):T=
      elements match{
      case List()=>throw new IllegalArgumentException("empty list!")
      case List(x)=>x
      case x::rest=>val maxRest = maxList(rest)
      if(x>maxRest) x
      else maxRest
      }
      }

implicit def doubleToInt(x: Double) = x.toInt
val i: Int = doubleToInt(3.5)
//i: Int = 3

转换（方法调用的）接受者
这种类型的隐式转换有两种主要用途：接受者转换使得新的类可以更为平滑地集成到现存类层级中；支持在语言中编写域特定语言（DSL）

隐式参数
可以让编译器插入隐式操作的最后的地方是通过参数列表。

class PreferredPrompt(val preference: String)
def greet(name:String)(implicit prompt:PreferredPrompt){
      println("Welcome,"+name+".The System is ready")
      println(prompt.preference)
      }
val bobsPrompt = new PreferredPrompt("relax> ")
greet("Bob")(bobsPrompt) 
//Welcome,Bob.The System is ready
//relax> 

带有隐式参数的函数

object MaxList1 {
  def maxListImpParm[T](elements: List[T])
        (implicit orderer: T => Ordered[T]): T =
  
    elements match {
      case List() => 
        throw new IllegalArgumentException("empty list!")
      case List(x) => x
      case x :: rest =>
        val maxRest = maxListImpParm(rest)(orderer)
        if (orderer(x) > maxRest) x
        else maxRest
    }
}
MaxList1.maxListImpParm(List(1,5,10,3))
//res4: Int = 10
 MaxList1.maxListImpParm(List(1.5, 5.2, 10.7, 53.14159))
//res6: Double = 53.14159
MaxList1.maxListImpParm(List("one", "two", "three"))
//res7: String = two

视界

//T<%Ordered[T] 视界
object MaxList2 {
  def maxList[T <% Ordered[T]](elements: List[T]): T =
    elements match {
      case List() => 
        throw new IllegalArgumentException("empty list!")
      case List(x) => x
      case x :: rest =>
        val maxRest = maxList(rest)  // (orderer) is implicit
        if (x > maxRest) x           // orderer(x) is implicit
        else maxRest
    }
}