美文网首页
【2019-06-05】隐式转换和参数

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

作者: BigBigFlower | 来源:发表于2019-06-05 11:16 被阅读0次

    隐式转换
    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
        }
    }
    

    相关文章

      网友评论

          本文标题:【2019-06-05】隐式转换和参数

          本文链接:https://www.haomeiwen.com/subject/xiyrxctx.html