隐式转换系统

In [1]:

    

// 需求场景：
// 提供一个计算销售税的方法
// 条件：
// 1. 某些应用需要知道当前事务发生的具体地点，以便增收税
// 2. 为了促进购物消费,某些地方可能将年假最后几天定位“免税期”

def calcTax(amount: Float)(implicit rate: Float): Float = amount*rate

object SimpleStateSalesTax {
    implicit val rate: Float = 0.05F
}

case class ComplicatedSalesTaxData(
    baseRate: Float,
    isTaxHoliday: Boolean,
    storeId: Int
)

object ComplicatedSalesTax {
    private def extraTaxRateForStore(id: Int): Float = {
        // 可以通过id推断商铺地点，再计算附加税
        0.0F
    }
    
    implicit def rate(implicit cstd: ComplicatedSalesTaxData): Float =
        if (cstd.isTaxHoliday) 0.0F
        else cstd.baseRate + extraTaxRateForStore(cstd.storeId)
}


    

    






defined function calcTax
defined object SimpleStateSalesTax
defined class ComplicatedSalesTaxData
defined object ComplicatedSalesTax

In [2]:

    

{
    import SimpleStateSalesTax.rate
    
    val amount = 100F
    println(s"Tax on $amount = ${calcTax(amount)}")
}


    

    




Tax on 100.0 = 5.0






    






import SimpleStateSalesTax.rate
amount: Float = 100.0F

In [3]:

    

{
    import ComplicatedSalesTax.rate
    implicit val myStore = ComplicatedSalesTaxData(0.06F, false, 1010)
    
    val amount = 100F
    println(s"Tax on $amount = ${calcTax(amount)}")
}


    

    




Tax on 100.0 = 6.0






    






import ComplicatedSalesTax.rate
myStore: ComplicatedSalesTaxData = ComplicatedSalesTaxData(0.06F, false, 1010)
amount: Float = 100.0F

In [4]:

    

import math.Ordering

case class MyList[A](list: List[A]) {
    def sortBy1[B](f: A => B)(implicit ord: Ordering[B]): List[A] = 
        list.sortBy(f)(ord)
    
    def sortBy2[B: Ordering](f: A => B): List[A] =
        list.sortBy(f)(implicitly[Ordering[B]])
}


    

    






import math.Ordering
defined class MyList

In [5]:

    

val list = MyList(List(1, 3, 5, 2, 4))


    

    






list: MyList[Int] = MyList(List(1, 3, 5, 2, 4))

In [6]:

    

list sortBy1 (i => -i)


    

    






res5: List[Int] = List(5, 4, 3, 2, 1)

In [7]:

    

list sortBy2 (i => -i)


    

    






res6: List[Int] = List(5, 4, 3, 2, 1)

In [8]:

    

object M {
    implicit object IntMarker
    implicit object StringMarker
    
    def m(seq: Seq[Int])(implicit i: IntMarker.type): Unit = println(s"Seq[Int]: $seq")
    def m(seq: Seq[String])(implicit s: StringMarker.type): Unit = println(s"Seq[String]: $seq")
}


    

    






defined object M

In [9]:

    

import M._


    

    






import M._

In [10]:

    

m(List(1, 2, 3))


    

    




Seq[Int]: List(1, 2, 3)






    

In [11]:

    

m(List("one", "two", "three"))


    

    




Seq[String]: List(one, two, three)






    

In [12]:

    

IntMarker


    

    






res11: IntMarker.type = cmd7$$user$M$IntMarker$@39546a

In [13]:

    

StringMarker


    

    






res12: StringMarker.type = cmd7$$user$M$StringMarker$@a1f49b